GDB (xrefs)
Loading...
Searching...
No Matches
dtrace-probe.c
Go to the documentation of this file.
1/* DTrace probe support for GDB.
2
3 Copyright (C) 2014-2023 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 "elf-bfd.h"
25#include "gdbtypes.h"
26#include "obstack.h"
27#include "objfiles.h"
28#include "complaints.h"
29#include "value.h"
30#include "ax.h"
31#include "ax-gdb.h"
32#include "language.h"
33#include "parser-defs.h"
34#include "inferior.h"
35#include "expop.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/* The following structure represents a single argument for the
45 probe. */
46
48{
49 dtrace_probe_arg (struct type *type_, std::string &&type_str_,
50 expression_up &&expr_)
51 : type (type_), type_str (std::move (type_str_)),
52 expr (std::move (expr_))
53 {}
54
55 /* The type of the probe argument. */
56 struct type *type;
57
58 /* A string describing the type. */
59 std::string type_str;
60
61 /* The argument converted to an internal GDB expression. */
63};
64
65/* The following structure represents an enabler for a probe. */
66
68{
69 /* Program counter where the is-enabled probe is installed. The
70 contents (nops, whatever...) stored at this address are
71 architecture dependent. */
72 CORE_ADDR address;
73};
74
75/* Class that implements the static probe methods for "stap" probes. */
76
78{
79public:
80 /* See probe.h. */
81 bool is_linespec (const char **linespecp) const override;
82
83 /* See probe.h. */
84 void get_probes (std::vector<std::unique_ptr<probe>> *probesp,
85 struct objfile *objfile) const override;
86
87 /* See probe.h. */
88 const char *type_name () const override;
89
90 /* See probe.h. */
91 bool can_enable () const override
92 {
93 return true;
94 }
95
96 /* See probe.h. */
97 std::vector<struct info_probe_column> gen_info_probes_table_header
98 () const override;
99};
100
101/* DTrace static_probe_ops. */
102
104
105/* The following structure represents a dtrace probe. */
106
107class dtrace_probe : public probe
108{
109public:
110 /* Constructor for dtrace_probe. */
111 dtrace_probe (std::string &&name_, std::string &&provider_, CORE_ADDR address_,
112 struct gdbarch *arch_,
113 std::vector<struct dtrace_probe_arg> &&args_,
114 std::vector<struct dtrace_probe_enabler> &&enablers_)
115 : probe (std::move (name_), std::move (provider_), address_, arch_),
116 m_args (std::move (args_)),
117 m_enablers (std::move (enablers_)),
118 m_args_expr_built (false)
119 {}
120
121 /* See probe.h. */
122 CORE_ADDR get_relocated_address (struct objfile *objfile) override;
123
124 /* See probe.h. */
125 unsigned get_argument_count (struct gdbarch *gdbarch) override;
126
127 /* See probe.h. */
128 bool can_evaluate_arguments () const override;
129
130 /* See probe.h. */
131 struct value *evaluate_argument (unsigned n,
132 frame_info_ptr frame) override;
133
134 /* See probe.h. */
135 void compile_to_ax (struct agent_expr *aexpr,
136 struct axs_value *axs_value,
137 unsigned n) override;
138
139 /* See probe.h. */
140 const static_probe_ops *get_static_ops () const override;
141
142 /* See probe.h. */
143 std::vector<const char *> gen_info_probes_table_values () const override;
144
145 /* See probe.h. */
146 void enable () override;
147
148 /* See probe.h. */
149 void disable () override;
150
151 /* Return the Nth argument of the probe. */
152 struct dtrace_probe_arg *get_arg_by_number (unsigned n,
153 struct gdbarch *gdbarch);
154
155 /* Build the GDB internal expression that, once evaluated, will
156 calculate the values of the arguments of the probe. */
157 void build_arg_exprs (struct gdbarch *gdbarch);
158
159 /* Determine whether the probe is "enabled" or "disabled". A
160 disabled probe is a probe in which one or more enablers are
161 disabled. */
162 bool is_enabled () const;
163
164private:
165 /* A probe can have zero or more arguments. */
166 std::vector<struct dtrace_probe_arg> m_args;
167
168 /* A probe can have zero or more "enablers" associated with it. */
169 std::vector<struct dtrace_probe_enabler> m_enablers;
170
171 /* Whether the expressions for the arguments have been built. */
173};
174
175/* DOF programs can contain an arbitrary number of sections of 26
176 different types. In order to support DTrace USDT probes we only
177 need to handle a subset of these section types, fortunately. These
178 section types are defined in the following enumeration.
179
180 See linux/dtrace/dof_defines.h for a complete list of section types
181 along with their values. */
182
184{
185 /* Null section. */
187 /* A dof_ecbdesc_t. */
189 /* A string table. */
191 /* A dof_provider_t */
193 /* Array of dof_probe_t */
195 /* An array of probe arg mappings. */
197 /* An array of probe arg offsets. */
199 /* An array of probe is-enabled offsets. */
202
203/* The following collection of data structures map the structure of
204 DOF entities. Again, we only cover the subset of DOF used to
205 implement USDT probes.
206
207 See linux/dtrace/dof.h header for a complete list of data
208 structures. */
209
210/* Offsets to index the dofh_ident[] array defined below. */
211
213{
214 /* First byte of the magic number. */
216 /* Second byte of the magic number. */
218 /* Third byte of the magic number. */
220 /* Fourth byte of the magic number. */
222 /* An enum_dof_encoding value. */
225
226/* Possible values for dofh_ident[DOF_ID_ENCODING]. */
227
229{
230 /* The DOF program is little-endian. */
232 /* The DOF program is big-endian. */
235
236/* A DOF header, which describes the contents of a DOF program: number
237 of sections, size, etc. */
238
240{
241 /* Identification bytes (see above). */
242 uint8_t dofh_ident[16];
243 /* File attribute flags (if any). */
244 uint32_t dofh_flags;
245 /* Size of file header in bytes. */
246 uint32_t dofh_hdrsize;
247 /* Size of section header in bytes. */
248 uint32_t dofh_secsize;
249 /* Number of section headers. */
250 uint32_t dofh_secnum;
251 /* File offset of section headers. */
252 uint64_t dofh_secoff;
253 /* File size of loadable portion. */
254 uint64_t dofh_loadsz;
255 /* File size of entire DOF file. */
256 uint64_t dofh_filesz;
257 /* Reserved for future use. */
258 uint64_t dofh_pad;
259};
260
261/* A DOF section, whose contents depend on its type. The several
262 supported section types are described in the enum
263 dtrace_dof_sect_type above. */
264
266{
267 /* Section type (see the define above). */
268 uint32_t dofs_type;
269 /* Section data memory alignment. */
270 uint32_t dofs_align;
271 /* Section flags (if any). */
272 uint32_t dofs_flags;
273 /* Size of section entry (if table). */
274 uint32_t dofs_entsize;
275 /* DOF + offset points to the section data. */
276 uint64_t dofs_offset;
277 /* Size of section data in bytes. */
278 uint64_t dofs_size;
279};
280
281/* A DOF provider, which is the provider of a probe. */
282
284{
285 /* Link to a DTRACE_DOF_SECT_TYPE_STRTAB section. */
286 uint32_t dofpv_strtab;
287 /* Link to a DTRACE_DOF_SECT_TYPE_PROBES section. */
288 uint32_t dofpv_probes;
289 /* Link to a DTRACE_DOF_SECT_TYPE_PRARGS section. */
290 uint32_t dofpv_prargs;
291 /* Link to a DTRACE_DOF_SECT_TYPE_PROFFS section. */
292 uint32_t dofpv_proffs;
293 /* Provider name string. */
294 uint32_t dofpv_name;
295 /* Provider attributes. */
297 /* Module attributes. */
298 uint32_t dofpv_modattr;
299 /* Function attributes. */
301 /* Name attributes. */
303 /* Args attributes. */
305 /* Link to a DTRACE_DOF_SECT_PRENOFFS section. */
307};
308
309/* A set of DOF probes and is-enabled probes sharing a base address
310 and several attributes. The particular locations and attributes of
311 each probe are maintained in arrays in several other DOF sections.
312 See the comment in dtrace_process_dof_probe for details on how
313 these attributes are stored. */
314
316{
317 /* Probe base address or offset. */
318 uint64_t dofpr_addr;
319 /* Probe function string. */
320 uint32_t dofpr_func;
321 /* Probe name string. */
322 uint32_t dofpr_name;
323 /* Native argument type strings. */
324 uint32_t dofpr_nargv;
325 /* Translated argument type strings. */
326 uint32_t dofpr_xargv;
327 /* Index of first argument mapping. */
328 uint32_t dofpr_argidx;
329 /* Index of first offset entry. */
330 uint32_t dofpr_offidx;
331 /* Native argument count. */
332 uint8_t dofpr_nargc;
333 /* Translated argument count. */
334 uint8_t dofpr_xargc;
335 /* Number of offset entries for probe. */
336 uint16_t dofpr_noffs;
337 /* Index of first is-enabled offset. */
339 /* Number of is-enabled offsets. */
341 /* Reserved for future use. */
342 uint16_t dofpr_pad1;
343 /* Reserved for future use. */
344 uint32_t dofpr_pad2;
345};
346
347/* DOF supports two different encodings: MSB (big-endian) and LSB
348 (little-endian). The encoding is itself encoded in the DOF header.
349 The following function returns an unsigned value in the host
350 endianness. */
351
352#define DOF_UINT(dof, field) \
353 extract_unsigned_integer ((gdb_byte *) &(field), \
354 sizeof ((field)), \
355 (((dof)->dofh_ident[DTRACE_DOF_ID_ENCODING] \
356 == DTRACE_DOF_ENCODE_MSB) \
357 ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE))
358
359/* The following macro applies a given byte offset to a DOF (a pointer
360 to a dtrace_dof_hdr structure) and returns the resulting
361 address. */
362
363#define DTRACE_DOF_PTR(dof, offset) (&((char *) (dof))[(offset)])
364
365/* The following macro returns a pointer to the beginning of a given
366 section in a DOF object. The section is referred to by its index
367 in the sections array. */
368
369#define DTRACE_DOF_SECT(dof, idx) \
370 ((struct dtrace_dof_sect *) \
371 DTRACE_DOF_PTR ((dof), \
372 DOF_UINT ((dof), (dof)->dofh_secoff) \
373 + ((idx) * DOF_UINT ((dof), (dof)->dofh_secsize))))
374
375/* Helper function to examine the probe described by the given PROBE
376 and PROVIDER data structures and add it to the PROBESP vector.
377 STRTAB, OFFTAB, EOFFTAB and ARGTAB are pointers to tables in the
378 DOF program containing the attributes for the probe. */
379
380static void
382 struct gdbarch *gdbarch,
383 std::vector<std::unique_ptr<probe>> *probesp,
384 struct dtrace_dof_hdr *dof,
385 struct dtrace_dof_probe *probe,
386 struct dtrace_dof_provider *provider,
387 char *strtab, char *offtab, char *eofftab,
388 char *argtab, uint64_t strtab_size)
389{
390 int i, j, num_probes, num_enablers;
391 char *p;
392
393 /* Each probe section can define zero or more probes of two
394 different types:
395
396 - probe->dofpr_noffs regular probes whose program counters are
397 stored in 32bit words starting at probe->dofpr_addr +
398 offtab[probe->dofpr_offidx].
399
400 - probe->dofpr_nenoffs is-enabled probes whose program counters
401 are stored in 32bit words starting at probe->dofpr_addr +
402 eofftab[probe->dofpr_enoffidx].
403
404 However is-enabled probes are not probes per-se, but an
405 optimization hack that is implemented in the kernel in a very
406 similar way than normal probes. This is how we support
407 is-enabled probes on GDB:
408
409 - Our probes are always DTrace regular probes.
410
411 - Our probes can be associated with zero or more "enablers". The
412 list of enablers is built from the is-enabled probes defined in
413 the Probe section.
414
415 - Probes having a non-empty list of enablers can be enabled or
416 disabled using the `enable probe' and `disable probe' commands
417 respectively. The `Enabled' column in the output of `info
418 probes' will read `yes' if the enablers are activated, `no'
419 otherwise.
420
421 - Probes having an empty list of enablers are always enabled.
422 The `Enabled' column in the output of `info probes' will
423 read `always'.
424
425 It follows that if there are DTrace is-enabled probes defined for
426 some provider/name but no DTrace regular probes defined then the
427 GDB user wont be able to enable/disable these conditionals. */
428
429 num_probes = DOF_UINT (dof, probe->dofpr_noffs);
430 if (num_probes == 0)
431 return;
432
433 /* Build the list of enablers for the probes defined in this Probe
434 DOF section. */
435 std::vector<struct dtrace_probe_enabler> enablers;
436 num_enablers = DOF_UINT (dof, probe->dofpr_nenoffs);
437 for (i = 0; i < num_enablers; i++)
438 {
439 struct dtrace_probe_enabler enabler;
440 uint32_t enabler_offset
441 = ((uint32_t *) eofftab)[DOF_UINT (dof, probe->dofpr_enoffidx) + i];
442
443 enabler.address = DOF_UINT (dof, probe->dofpr_addr)
444 + DOF_UINT (dof, enabler_offset);
445 enablers.push_back (enabler);
446 }
447
448 for (i = 0; i < num_probes; i++)
449 {
450 uint32_t probe_offset
451 = ((uint32_t *) offtab)[DOF_UINT (dof, probe->dofpr_offidx) + i];
452
453 /* Set the provider and the name of the probe. */
454 const char *probe_provider
455 = strtab + DOF_UINT (dof, provider->dofpv_name);
456 const char *name = strtab + DOF_UINT (dof, probe->dofpr_name);
457
458 /* The probe address. */
459 CORE_ADDR address
460 = DOF_UINT (dof, probe->dofpr_addr) + DOF_UINT (dof, probe_offset);
461
462 /* Number of arguments in the probe. */
463 int probe_argc = DOF_UINT (dof, probe->dofpr_nargc);
464
465 /* Store argument type descriptions. A description of the type
466 of the argument is in the (J+1)th null-terminated string
467 starting at 'strtab' + 'probe->dofpr_nargv'. */
468 std::vector<struct dtrace_probe_arg> args;
469 p = strtab + DOF_UINT (dof, probe->dofpr_nargv);
470 for (j = 0; j < probe_argc; j++)
471 {
473
474 /* Set arg.expr to ensure all fields in expr are initialized and
475 the compiler will not warn when arg is used. */
476 std::string type_str (p);
477
478 /* Use strtab_size as a sentinel. */
479 while (*p++ != '\0' && p - strtab < strtab_size)
480 ;
481
482 /* Try to parse a type expression from the type string. If
483 this does not work then we set the type to `long
484 int'. */
486
487 try
488 {
489 expr = parse_expression_with_language (type_str.c_str (),
490 language_c);
491 }
492 catch (const gdb_exception_error &ex)
493 {
494 }
495
496 if (expr != NULL && expr->first_opcode () == OP_TYPE)
497 type = expr->evaluate_type ()->type ();
498
499 args.emplace_back (type, std::move (type_str), std::move (expr));
500 }
501
502 std::vector<struct dtrace_probe_enabler> enablers_copy = enablers;
503 dtrace_probe *ret = new dtrace_probe (std::string (name),
504 std::string (probe_provider),
505 address, gdbarch,
506 std::move (args),
507 std::move (enablers_copy));
508
509 /* Successfully created probe. */
510 probesp->emplace_back (ret);
511 }
512}
513
514/* Helper function to collect the probes described in the DOF program
515 whose header is pointed by DOF and add them to the PROBESP vector.
516 SECT is the ELF section containing the DOF program and OBJFILE is
517 its containing object file. */
518
519static void
520dtrace_process_dof (asection *sect, struct objfile *objfile,
521 std::vector<std::unique_ptr<probe>> *probesp,
522 struct dtrace_dof_hdr *dof)
523{
524 struct gdbarch *gdbarch = objfile->arch ();
525 struct dtrace_dof_sect *section;
526 int i;
527
528 /* The first step is to check for the DOF magic number. If no valid
529 DOF data is found in the section then a complaint is issued to
530 the user and the section skipped. */
531 if (dof->dofh_ident[DTRACE_DOF_ID_MAG0] != 0x7F
532 || dof->dofh_ident[DTRACE_DOF_ID_MAG1] != 'D'
533 || dof->dofh_ident[DTRACE_DOF_ID_MAG2] != 'O'
534 || dof->dofh_ident[DTRACE_DOF_ID_MAG3] != 'F')
535 goto invalid_dof_data;
536
537 /* Make sure the encoding mark is either DTRACE_DOF_ENCODE_LSB or
538 DTRACE_DOF_ENCODE_MSB. */
541 goto invalid_dof_data;
542
543 /* Make sure this DOF is not an enabling DOF, i.e. there are no ECB
544 Description sections. */
545 section = (struct dtrace_dof_sect *) DTRACE_DOF_PTR (dof,
546 DOF_UINT (dof, dof->dofh_secoff));
547 for (i = 0; i < DOF_UINT (dof, dof->dofh_secnum); i++, section++)
549 return;
550
551 /* Iterate over any section of type Provider and extract the probe
552 information from them. If there are no "provider" sections on
553 the DOF then we just return. */
554 section = (struct dtrace_dof_sect *) DTRACE_DOF_PTR (dof,
555 DOF_UINT (dof, dof->dofh_secoff));
556 for (i = 0; i < DOF_UINT (dof, dof->dofh_secnum); i++, section++)
557 if (DOF_UINT (dof, section->dofs_type) == DTRACE_DOF_SECT_TYPE_PROVIDER)
558 {
559 struct dtrace_dof_provider *provider = (struct dtrace_dof_provider *)
560 DTRACE_DOF_PTR (dof, DOF_UINT (dof, section->dofs_offset));
561 struct dtrace_dof_sect *strtab_s
562 = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_strtab));
563 struct dtrace_dof_sect *probes_s
564 = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_probes));
565 struct dtrace_dof_sect *args_s
566 = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_prargs));
567 struct dtrace_dof_sect *offsets_s
568 = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_proffs));
569 struct dtrace_dof_sect *eoffsets_s
570 = DTRACE_DOF_SECT (dof, DOF_UINT (dof, provider->dofpv_prenoffs));
571 char *strtab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, strtab_s->dofs_offset));
572 char *offtab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, offsets_s->dofs_offset));
573 char *eofftab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, eoffsets_s->dofs_offset));
574 char *argtab = DTRACE_DOF_PTR (dof, DOF_UINT (dof, args_s->dofs_offset));
575 unsigned int entsize = DOF_UINT (dof, probes_s->dofs_entsize);
576 int num_probes;
577
578 if (DOF_UINT (dof, section->dofs_size)
579 < sizeof (struct dtrace_dof_provider))
580 {
581 /* The section is smaller than expected, so do not use it.
582 This has been observed on x86-solaris 10. */
583 goto invalid_dof_data;
584 }
585
586 /* Very, unlikely, but could crash gdb if not handled
587 properly. */
588 if (entsize == 0)
589 goto invalid_dof_data;
590
591 num_probes = DOF_UINT (dof, probes_s->dofs_size) / entsize;
592
593 for (i = 0; i < num_probes; i++)
594 {
595 struct dtrace_dof_probe *probe = (struct dtrace_dof_probe *)
596 DTRACE_DOF_PTR (dof, DOF_UINT (dof, probes_s->dofs_offset)
597 + (i * DOF_UINT (dof, probes_s->dofs_entsize)));
598
600 gdbarch, probesp,
601 dof, probe,
602 provider, strtab, offtab, eofftab, argtab,
603 DOF_UINT (dof, strtab_s->dofs_size));
604 }
605 }
606
607 return;
608
609 invalid_dof_data:
610 complaint (_("skipping section '%s' which does not contain valid DOF data."),
611 sect->name);
612}
613
614/* Implementation of 'build_arg_exprs' method. */
615
616void
618{
619 size_t argc = 0;
620 m_args_expr_built = true;
621
622 /* Iterate over the arguments in the probe and build the
623 corresponding GDB internal expression that will generate the
624 value of the argument when executed at the PC of the probe. */
625 for (dtrace_probe_arg &arg : m_args)
626 {
627 /* Initialize the expression builder. The language does not
628 matter, since we are using our own parser. */
630
631 /* The argument value, which is ABI dependent and casted to
632 `long int'. */
634 argc);
635
636 /* Casting to the expected type, but only if the type was
637 recognized at probe load time. Otherwise the argument will
638 be evaluated as the long integer passed to the probe. */
639 if (arg.type != NULL)
640 op = expr::make_operation<expr::unop_cast_operation> (std::move (op),
641 arg.type);
642
643 builder.set_operation (std::move (op));
644 arg.expr = builder.release ();
645 ++argc;
646 }
647}
648
649/* Implementation of 'get_arg_by_number' method. */
650
651struct dtrace_probe_arg *
653{
655 this->build_arg_exprs (gdbarch);
656
657 if (n > m_args.size ())
658 internal_error (_("Probe '%s' has %d arguments, but GDB is requesting\n"
659 "argument %u. This should not happen. Please\n"
660 "report this bug."),
661 this->get_name ().c_str (),
662 (int) m_args.size (), n);
663
664 return &m_args[n];
665}
666
667/* Implementation of the probe is_enabled method. */
668
669bool
671{
672 struct gdbarch *gdbarch = this->get_gdbarch ();
673
674 for (const dtrace_probe_enabler &enabler : m_enablers)
675 if (!gdbarch_dtrace_probe_is_enabled (gdbarch, enabler.address))
676 return false;
677
678 return true;
679}
680
681/* Implementation of the get_probe_address method. */
682
683CORE_ADDR
685{
686 return this->get_address () + objfile->text_section_offset ();
687}
688
689/* Implementation of the get_argument_count method. */
690
691unsigned
693{
694 return m_args.size ();
695}
696
697/* Implementation of the can_evaluate_arguments method. */
698
699bool
701{
702 struct gdbarch *gdbarch = this->get_gdbarch ();
703
705}
706
707/* Implementation of the evaluate_argument method. */
708
709struct value *
711 frame_info_ptr frame)
712{
713 struct gdbarch *gdbarch = this->get_gdbarch ();
714 struct dtrace_probe_arg *arg;
715
716 arg = this->get_arg_by_number (n, gdbarch);
717 return arg->expr->evaluate (arg->type);
718}
719
720/* Implementation of the compile_to_ax method. */
721
722void
724 unsigned n)
725{
726 struct dtrace_probe_arg *arg;
727
728 arg = this->get_arg_by_number (n, expr->gdbarch);
729 arg->expr->op->generate_ax (arg->expr.get (), expr, value);
730
732 value->type = arg->type;
733}
734
735/* Implementation of the 'get_static_ops' method. */
736
737const static_probe_ops *
742
743/* Implementation of the gen_info_probes_table_values method. */
744
745std::vector<const char *>
747{
748 const char *val = NULL;
749
750 if (m_enablers.empty ())
751 val = "always";
753 val = "unknown";
754 else if (this->is_enabled ())
755 val = "yes";
756 else
757 val = "no";
758
759 return std::vector<const char *> { val };
760}
761
762/* Implementation of the enable method. */
763
764void
766{
767 struct gdbarch *gdbarch = this->get_gdbarch ();
768
769 /* Enabling a dtrace probe implies patching the text section of the
770 running process, so make sure the inferior is indeed running. */
771 if (inferior_ptid == null_ptid)
772 error (_("No inferior running"));
773
774 /* Fast path. */
775 if (this->is_enabled ())
776 return;
777
778 /* Iterate over all defined enabler in the given probe and enable
779 them all using the corresponding gdbarch hook. */
780 for (const dtrace_probe_enabler &enabler : m_enablers)
782 gdbarch_dtrace_enable_probe (gdbarch, enabler.address);
783}
784
785
786/* Implementation of the disable_probe method. */
787
788void
790{
791 struct gdbarch *gdbarch = this->get_gdbarch ();
792
793 /* Disabling a dtrace probe implies patching the text section of the
794 running process, so make sure the inferior is indeed running. */
795 if (inferior_ptid == null_ptid)
796 error (_("No inferior running"));
797
798 /* Fast path. */
799 if (!this->is_enabled ())
800 return;
801
802 /* Are we trying to disable a probe that does not have any enabler
803 associated? */
804 if (m_enablers.empty ())
805 error (_("Probe %s:%s cannot be disabled: no enablers."),
806 this->get_provider ().c_str (), this->get_name ().c_str ());
807
808 /* Iterate over all defined enabler in the given probe and disable
809 them all using the corresponding gdbarch hook. */
810 for (dtrace_probe_enabler &enabler : m_enablers)
812 gdbarch_dtrace_disable_probe (gdbarch, enabler.address);
813}
814
815/* Implementation of the is_linespec method. */
816
817bool
818dtrace_static_probe_ops::is_linespec (const char **linespecp) const
819{
820 static const char *const keywords[] = { "-pdtrace", "-probe-dtrace", NULL };
821
822 return probe_is_linespec_by_keyword (linespecp, keywords);
823}
824
825/* Implementation of the get_probes method. */
826
827void
829 (std::vector<std::unique_ptr<probe>> *probesp,
830 struct objfile *objfile) const
831{
832 bfd *abfd = objfile->obfd.get ();
833 asection *sect = NULL;
834
835 /* Do nothing in case this is a .debug file, instead of the objfile
836 itself. */
838 return;
839
840 /* Iterate over the sections in OBJFILE looking for DTrace
841 information. */
842 for (sect = abfd->sections; sect != NULL; sect = sect->next)
843 {
844 if (elf_section_data (sect)->this_hdr.sh_type == SHT_SUNW_dof)
845 {
846 bfd_byte *dof;
847
848 /* Read the contents of the DOF section and then process it to
849 extract the information of any probe defined into it. */
850 if (bfd_malloc_and_get_section (abfd, sect, &dof) && dof != NULL)
851 dtrace_process_dof (sect, objfile, probesp,
852 (struct dtrace_dof_hdr *) dof);
853 else
854 complaint (_("could not obtain the contents of"
855 "section '%s' in objfile `%s'."),
856 bfd_section_name (sect), bfd_get_filename (abfd));
857
858 xfree (dof);
859 }
860 }
861}
862
863/* Implementation of the type_name method. */
864
865const char *
867{
868 return "dtrace";
869}
870
871/* Implementation of the gen_info_probes_table_header method. */
872
873std::vector<struct info_probe_column>
875{
876 struct info_probe_column dtrace_probe_column;
877
878 dtrace_probe_column.field_name = "enabled";
879 dtrace_probe_column.print_name = _("Enabled");
880
881 return std::vector<struct info_probe_column> { dtrace_probe_column };
882}
883
884/* Implementation of the `info probes dtrace' command. */
885
886static void
887info_probes_dtrace_command (const char *arg, int from_tty)
888{
890}
891
893void
895{
897
899 _("\
900Show information about DTrace static probes.\n\
901Usage: info probes dtrace [PROVIDER [NAME [OBJECT]]]\n\
902Each argument is a regular expression, used to select probes.\n\
903PROVIDER matches probe provider names.\n\
904NAME matches the probe names.\n\
905OBJECT matches the executable or shared library name."),
907}
const char *const name
void xfree(void *)
void require_rvalue(struct agent_expr *ax, struct axs_value *value)
Definition ax-gdb.c:672
dtrace_probe(std::string &&name_, std::string &&provider_, CORE_ADDR address_, struct gdbarch *arch_, std::vector< struct dtrace_probe_arg > &&args_, std::vector< struct dtrace_probe_enabler > &&enablers_)
unsigned get_argument_count(struct gdbarch *gdbarch) override
const static_probe_ops * get_static_ops() const override
std::vector< struct dtrace_probe_arg > m_args
void enable() override
CORE_ADDR get_relocated_address(struct objfile *objfile) override
bool can_evaluate_arguments() const override
std::vector< struct dtrace_probe_enabler > m_enablers
bool m_args_expr_built
std::vector< const char * > gen_info_probes_table_values() const override
struct value * evaluate_argument(unsigned n, frame_info_ptr frame) override
bool is_enabled() const
struct dtrace_probe_arg * get_arg_by_number(unsigned n, struct gdbarch *gdbarch)
void build_arg_exprs(struct gdbarch *gdbarch)
void disable() override
void compile_to_ax(struct agent_expr *aexpr, struct axs_value *axs_value, unsigned n) override
bool can_enable() const override
void get_probes(std::vector< std::unique_ptr< probe > > *probesp, struct objfile *objfile) const override
bool is_linespec(const char **linespecp) const override
std::vector< struct info_probe_column > gen_info_probes_table_header() const override
const char * type_name() const override
Definition probe.h:115
const std::string & get_name() const
Definition probe.h:199
const std::string & get_provider() const
Definition probe.h:205
CORE_ADDR get_address() const
Definition probe.h:211
struct gdbarch * get_gdbarch() const
Definition probe.h:217
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition cli-decode.c:233
@ class_info
Definition command.h:59
#define complaint(FMT,...)
Definition complaints.h:47
@ language_c
Definition defs.h:213
static void dtrace_process_dof_probe(struct objfile *objfile, struct gdbarch *gdbarch, std::vector< std::unique_ptr< probe > > *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)
#define DTRACE_DOF_SECT(dof, idx)
dtrace_dof_sect_type
@ DTRACE_DOF_SECT_TYPE_ECBDESC
@ DTRACE_DOF_SECT_TYPE_PROVIDER
@ DTRACE_DOF_SECT_TYPE_PRENOFFS
@ DTRACE_DOF_SECT_TYPE_PROFFS
@ DTRACE_DOF_SECT_TYPE_STRTAB
@ DTRACE_DOF_SECT_TYPE_NONE
@ DTRACE_DOF_SECT_TYPE_PRARGS
@ DTRACE_DOF_SECT_TYPE_PROBES
const dtrace_static_probe_ops dtrace_static_probe_ops
static void info_probes_dtrace_command(const char *arg, int from_tty)
static void dtrace_process_dof(asection *sect, struct objfile *objfile, std::vector< std::unique_ptr< probe > > *probesp, struct dtrace_dof_hdr *dof)
dtrace_dof_encoding
@ DTRACE_DOF_ENCODE_LSB
@ DTRACE_DOF_ENCODE_MSB
dtrace_dof_ident
@ DTRACE_DOF_ID_MAG0
@ DTRACE_DOF_ID_ENCODING
@ DTRACE_DOF_ID_MAG1
@ DTRACE_DOF_ID_MAG2
@ DTRACE_DOF_ID_MAG3
#define SHT_SUNW_dof
#define DTRACE_DOF_PTR(dof, offset)
void _initialize_dtrace_probe()
#define DOF_UINT(dof, field)
std::unique_ptr< expression > expression_up
Definition expression.h:241
expression_up parse_expression_with_language(const char *string, enum language lang)
Definition parse.c:472
void gdbarch_dtrace_enable_probe(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition gdbarch.c:4813
bool gdbarch_dtrace_parse_probe_argument_p(struct gdbarch *gdbarch)
Definition gdbarch.c:4758
bool gdbarch_dtrace_enable_probe_p(struct gdbarch *gdbarch)
Definition gdbarch.c:4806
expr::operation_up gdbarch_dtrace_parse_probe_argument(struct gdbarch *gdbarch, int narg)
Definition gdbarch.c:4765
bool gdbarch_dtrace_probe_is_enabled_p(struct gdbarch *gdbarch)
Definition gdbarch.c:4782
int gdbarch_dtrace_probe_is_enabled(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition gdbarch.c:4789
void gdbarch_dtrace_disable_probe(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition gdbarch.c:4837
bool gdbarch_dtrace_disable_probe_p(struct gdbarch *gdbarch)
Definition gdbarch.c:4830
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition gdbtypes.c:6168
ptid_t inferior_ptid
Definition infcmd.c:74
const struct language_defn * current_language
Definition language.c:82
Definition ada-exp.h:87
std::unique_ptr< operation > operation_up
Definition expression.h:82
Definition aarch64.h:67
void info_probes_for_spops(const char *arg, int from_tty, const static_probe_ops *spops)
Definition probe.c:483
int probe_is_linespec_by_keyword(const char **linespecp, const char *const *keywords)
Definition probe.c:820
std::vector< const static_probe_ops * > all_static_probe_ops
Definition probe.c:975
struct cmd_list_element ** info_probes_cmdlist_get(void)
Definition probe.c:878
struct type * builtin_long
Definition gdbtypes.h:2081
uint32_t dofh_secsize
uint32_t dofh_flags
uint64_t dofh_filesz
uint32_t dofh_secnum
uint64_t dofh_pad
uint64_t dofh_secoff
uint32_t dofh_hdrsize
uint8_t dofh_ident[16]
uint64_t dofh_loadsz
uint16_t dofpr_nenoffs
uint32_t dofpr_offidx
uint32_t dofpr_enoffidx
uint32_t dofpr_argidx
uint32_t dofs_align
uint32_t dofs_entsize
uint64_t dofs_offset
uint32_t dofs_flags
std::string type_str
dtrace_probe_arg(struct type *type_, std::string &&type_str_, expression_up &&expr_)
struct type * type
expression_up expr
void set_operation(expr::operation_up &&op)
Definition parser-defs.h:73
ATTRIBUTE_UNUSED_RESULT expression_up release()
Definition parser-defs.h:52
const char * field_name
Definition probe.h:35
const char * print_name
Definition probe.h:39
struct objfile * separate_debug_objfile_backlink
Definition objfiles.h:830
struct gdbarch * arch() const
Definition objfiles.h:507
gdb_bfd_ref_ptr obfd
Definition objfiles.h:740
CORE_ADDR text_section_offset() const
Definition objfiles.h:482
Definition value.h:130
struct type * type() const
Definition value.h:180