From dc38c0ae43f0c98b203866eeeb88070d32db2c8d Mon Sep 17 00:00:00 2001 From: dsmith Date: Mon, 28 Aug 2006 17:59:50 +0000 Subject: 2006-08-28 David Smith * translate.cxx: Added inclusion of session.h. (translate_pass): Instead of asking each probe to emit itself, we ask the session's probes member variable to emit all the probes. * tapsets.cxx: Added inclusion of session.h. Added a register_probe member function to all derived_probe based classes. Added a derived_probe_group derived class for all probe types: (be_derived_probe_group): New class. (never_derived_probe_group): New class. (dwarf_derived_probe_group): New class. (timer_derived_probe_group): New class. (profile_derived_probe_group): New class. (mark_derived_probe_group): New class. (hrtimer_derived_probe_group): New class (derived_probe_group_container): New class. * elaborate.h: Removed inclusion of session.h since session.h now includes elaborate.h. (derived_probe): Added register_probe member function. (derived_probe_group): Added class definition. This is the base class of all of the derived probe groups - dwarf, timer, etc. (derived_probe_group_container): Added class definition. An instance of this class will be stored in the session and contain all the other probe groups. * elaborate.cxx (derived_probe_group::register_probe): Added derived_probe_group::register_probe stubs. (alias_derived_probe::register_probe): Added register_probe member function. (semantic_pass_symbols): After deriving a probe, the probes now register themselves with the session. * session.h: Includes elaborate.h to get derived_probe_group_container definition. systemtap_session class 'probes' member variable switched from a vector of derived probes to a derived_probe_group_container. * buildrun.cxx: Added inclusion of session.h since it was removed from elaborate.h. * main.cxx: Added inclusion of session.h since it was removed from elaborate.h. * parse.h: Added forward struct declarations. * staptree.h: Removed inclusion of session.h. --- tapsets.cxx | 342 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 342 insertions(+) (limited to 'tapsets.cxx') diff --git a/tapsets.cxx b/tapsets.cxx index 2aa5e1b7..1d491cc2 100644 --- a/tapsets.cxx +++ b/tapsets.cxx @@ -12,6 +12,7 @@ #include "elaborate.h" #include "tapsets.h" #include "translate.h" +#include "session.h" #include #include @@ -198,12 +199,27 @@ struct be_derived_probe: public derived_probe be_derived_probe (probe* p, probe_point* l, bool b): derived_probe (p, l), begin (b) {} + void register_probe (systemtap_session& s); + void emit_registrations (translator_output* o); void emit_deregistrations (translator_output* o); void emit_probe_entries (translator_output* o); }; +struct be_derived_probe_group: public derived_probe_group +{ +private: + vector probes; + +public: + virtual void register_probe(be_derived_probe* p) { probes.push_back (p); } + virtual size_t size () { return probes.size (); } + + virtual void emit_probes (translator_output* op, unparser* up); +}; + + struct be_builder: public derived_probe_builder { bool begin; @@ -219,6 +235,13 @@ struct be_builder: public derived_probe_builder }; +void +be_derived_probe::register_probe(systemtap_session& s) +{ + s.probes.register_probe(this); +} + + void be_derived_probe::emit_registrations (translator_output* o) { @@ -270,6 +293,17 @@ be_derived_probe::emit_probe_entries (translator_output* o) } +void +be_derived_probe_group::emit_probes (translator_output* op, unparser* up) +{ + for (unsigned i=0; i < probes.size(); i++) + { + op->newline (); + up->emit_probe (probes[i]); + } +} + + // ------------------------------------------------------------------------ // never probes are never run // ------------------------------------------------------------------------ @@ -279,12 +313,34 @@ struct never_derived_probe: public derived_probe never_derived_probe (probe* p): derived_probe (p) {} never_derived_probe (probe* p, probe_point* l): derived_probe (p, l) {} + void register_probe (systemtap_session& s); + void emit_registrations (translator_output* o); void emit_deregistrations (translator_output* o); void emit_probe_entries (translator_output* o); }; +struct never_derived_probe_group: public derived_probe_group +{ +private: + vector probes; + +public: + virtual void register_probe(never_derived_probe* p) { probes.push_back (p); } + virtual size_t size () { return probes.size (); } + + virtual void emit_probes (translator_output* op, unparser* up); +}; + + +void +never_derived_probe::register_probe(systemtap_session& s) +{ + s.probes.register_probe(this); +} + + struct never_builder: public derived_probe_builder { never_builder() {} @@ -317,6 +373,15 @@ never_derived_probe::emit_probe_entries (translator_output* o) } +void +never_derived_probe_group::emit_probes (translator_output* op, unparser* up) +{ + for (unsigned i=0; i < probes.size(); i++) + { + op->newline (); + up->emit_probe (probes[i]); + } +} // ------------------------------------------------------------------------ // Dwarf derived probes. @@ -1718,6 +1783,8 @@ struct dwarf_derived_probe : public derived_probe vector probe_points; bool has_return; + void register_probe (systemtap_session& s); + void add_probe_point(string const & funcname, char const * filename, int line, @@ -1742,6 +1809,20 @@ struct dwarf_derived_probe : public derived_probe virtual void emit_probe_entries (translator_output * o); }; + +struct dwarf_derived_probe_group: public derived_probe_group +{ +private: + vector probes; + +public: + virtual void register_probe(dwarf_derived_probe* p) { probes.push_back (p); } + virtual size_t size () { return probes.size (); } + + virtual void emit_probes (translator_output* op, unparser* up); +}; + + // Helper struct to thread through the dwfl callbacks. struct dwarf_query @@ -2938,6 +3019,13 @@ dwarf_var_expanding_copy_visitor::visit_target_symbol (target_symbol *e) } +void +dwarf_derived_probe::register_probe(systemtap_session& s) +{ + s.probes.register_probe(this); +} + + void dwarf_derived_probe::add_probe_point(string const & funcname, char const * filename, @@ -3374,6 +3462,17 @@ dwarf_derived_probe::emit_probe_entries (translator_output* o) } +void +dwarf_derived_probe_group::emit_probes (translator_output* op, unparser* up) +{ + for (unsigned i=0; i < probes.size(); i++) + { + op->newline (); + up->emit_probe (probes[i]); + } +} + + void dwarf_builder::build(systemtap_session & sess, probe * base, @@ -3464,6 +3563,8 @@ struct timer_derived_probe: public derived_probe timer_derived_probe (probe* p, probe_point* l, int64_t i, int64_t r, bool ms=false); + virtual void register_probe (systemtap_session& s); + virtual void emit_registrations (translator_output * o); virtual void emit_deregistrations (translator_output * o); virtual void emit_probe_entries (translator_output * o); @@ -3485,6 +3586,13 @@ timer_derived_probe::timer_derived_probe (probe* p, probe_point* l, int64_t i, i } +void +timer_derived_probe::register_probe(systemtap_session& s) +{ + s.probes.register_probe(this); +} + + void timer_derived_probe::emit_registrations (translator_output* o) { @@ -3540,6 +3648,30 @@ timer_derived_probe::emit_probe_entries (translator_output* o) } +struct timer_derived_probe_group: public derived_probe_group +{ +private: + vector probes; + +public: + virtual void register_probe(timer_derived_probe* p) { probes.push_back (p); } + virtual size_t size () { return probes.size (); } + + virtual void emit_probes (translator_output* op, unparser* up); +}; + + +void +timer_derived_probe_group::emit_probes (translator_output* op, unparser* up) +{ + for (unsigned i=0; i < probes.size(); i++) + { + op->newline (); + up->emit_probe (probes[i]); + } +} + + struct timer_builder: public derived_probe_builder { bool time_is_msecs; @@ -3581,6 +3713,8 @@ struct profile_derived_probe: public derived_probe profile_derived_probe (systemtap_session &s, probe* p, probe_point* l); + void register_probe (systemtap_session& s); + virtual void emit_registrations (translator_output * o); virtual void emit_deregistrations (translator_output * o); virtual void emit_probe_entries (translator_output * o); @@ -3603,6 +3737,13 @@ profile_derived_probe::profile_derived_probe (systemtap_session &s, probe* p, pr } +void +profile_derived_probe::register_probe(systemtap_session& s) +{ + s.probes.register_probe(this); +} + + void profile_derived_probe::emit_registrations (translator_output* o) { @@ -3660,6 +3801,31 @@ profile_derived_probe::emit_probe_entries (translator_output* o) } +struct profile_derived_probe_group: public derived_probe_group +{ +private: + vector probes; + +public: + virtual void register_probe(profile_derived_probe* p) { + probes.push_back (p); } + virtual size_t size () { return probes.size (); } + + virtual void emit_probes (translator_output* op, unparser* up); +}; + + +void +profile_derived_probe_group::emit_probes (translator_output* op, unparser* up) +{ + for (unsigned i=0; i < probes.size(); i++) + { + op->newline (); + up->emit_probe (probes[i]); + } +} + + struct profile_builder: public derived_probe_builder { profile_builder() {} @@ -3692,6 +3858,8 @@ struct mark_derived_probe: public derived_probe string module; string probe_sig_expanded; + void register_probe (systemtap_session& s); + void emit_registrations (translator_output * o); void emit_deregistrations (translator_output * o); void emit_probe_entries (translator_output * o); @@ -3808,6 +3976,13 @@ mark_derived_probe::mark_derived_probe (systemtap_session &s, } +void +mark_derived_probe::register_probe(systemtap_session& s) +{ + s.probes.register_probe(this); +} + + void mark_derived_probe::emit_probe_context_vars (translator_output* o) { @@ -3904,6 +4079,29 @@ mark_derived_probe::emit_deregistrations (translator_output * o) } +struct mark_derived_probe_group: public derived_probe_group +{ +private: + vector probes; + +public: + virtual void register_probe(mark_derived_probe* p) { probes.push_back (p); } + virtual size_t size () { return probes.size (); } + + virtual void emit_probes (translator_output* op, unparser* up); +}; + + +void +mark_derived_probe_group::emit_probes (translator_output* op, unparser* up) +{ + for (unsigned i=0; i < probes.size(); i++) + { + op->newline (); + up->emit_probe (probes[i]); + } +} + struct symboltable_extract { @@ -4114,6 +4312,8 @@ struct hrtimer_derived_probe: public derived_probe // so we don't have to loop over them in the other functions } + void register_probe (systemtap_session& s); + virtual void emit_interval (translator_output * o); virtual void emit_registrations (translator_output * o); @@ -4122,6 +4322,13 @@ struct hrtimer_derived_probe: public derived_probe }; +void +hrtimer_derived_probe::register_probe(systemtap_session& s) +{ + s.probes.register_probe(this); +} + + void hrtimer_derived_probe::emit_interval (translator_output* o) { @@ -4194,6 +4401,30 @@ hrtimer_derived_probe::emit_probe_entries (translator_output* o) } +struct hrtimer_derived_probe_group: public derived_probe_group +{ +private: + vector probes; + +public: + virtual void register_probe(hrtimer_derived_probe* p) { probes.push_back (p); } + virtual size_t size () { return probes.size (); } + + virtual void emit_probes (translator_output* op, unparser* up); +}; + + +void +hrtimer_derived_probe_group::emit_probes (translator_output* op, unparser* up) +{ + for (unsigned i=0; i < probes.size(); i++) + { + op->newline (); + up->emit_probe (probes[i]); + } +} + + struct hrtimer_builder: public derived_probe_builder { hrtimer_builder() {} @@ -4348,3 +4579,114 @@ register_standard_tapsets(systemtap_session & s) s.pattern_root->bind("kernel")->bind_str("mark")->bind(new mark_builder()); s.pattern_root->bind_str("module")->bind_str("mark")->bind(new mark_builder()); } + + +derived_probe_group_container::derived_probe_group_container (): + be_probe_group(new be_derived_probe_group), + dwarf_probe_group(new dwarf_derived_probe_group), + hrtimer_probe_group(new hrtimer_derived_probe_group), + mark_probe_group(new mark_derived_probe_group), + never_probe_group(new never_derived_probe_group), + profile_probe_group(new profile_derived_probe_group), + timer_probe_group(new timer_derived_probe_group) +{ +} + + +derived_probe_group_container::~derived_probe_group_container () +{ + delete be_probe_group; + delete dwarf_probe_group; + delete hrtimer_probe_group; + delete mark_probe_group; + delete never_probe_group; + delete profile_probe_group; + delete timer_probe_group; +} + + +void +derived_probe_group_container::register_probe(be_derived_probe* p) +{ + probes.push_back (p); + be_probe_group->register_probe(p); +} + + +void +derived_probe_group_container::register_probe(dwarf_derived_probe* p) +{ + probes.push_back (p); + dwarf_probe_group->register_probe(p); +} + + +void +derived_probe_group_container::register_probe(hrtimer_derived_probe* p) +{ + probes.push_back (p); + hrtimer_probe_group->register_probe(p); +} + + +void +derived_probe_group_container::register_probe(mark_derived_probe* p) +{ + probes.push_back (p); + mark_probe_group->register_probe(p); +} + + +void +derived_probe_group_container::register_probe(never_derived_probe* p) +{ + probes.push_back (p); + never_probe_group->register_probe(p); +} + + +void +derived_probe_group_container::register_probe(profile_derived_probe* p) +{ + probes.push_back (p); + profile_probe_group->register_probe(p); +} + + +void +derived_probe_group_container::register_probe(timer_derived_probe* p) +{ + probes.push_back (p); + timer_probe_group->register_probe(p); +} + + +void +derived_probe_group_container::emit_probes (translator_output* op, + unparser* up) +{ + // Sanity check. + size_t groups_size = be_probe_group->size () + + dwarf_probe_group->size () + + hrtimer_probe_group->size () + + mark_probe_group->size () + + never_probe_group->size () + + profile_probe_group->size () + + timer_probe_group->size (); + if (probes.size () != groups_size) + { + cerr << "There are " << probes.size () << " total probes, and " + << groups_size << " grouped probes\n"; + + throw runtime_error("internal probe mismatch"); + } + + // Let each probe group emit its probes. + be_probe_group->emit_probes (op, up); + dwarf_probe_group->emit_probes (op, up); + hrtimer_probe_group->emit_probes (op, up); + mark_probe_group->emit_probes (op, up); + never_probe_group->emit_probes (op, up); + profile_probe_group->emit_probes (op, up); + timer_probe_group->emit_probes (op, up); +} -- cgit