Separate the begin/end/error/never tapsets

1 files changed, 3 insertions, 202 deletions

diff --git a/tapsets.cxx b/tapsets.cxx
index 9b6ad713..e6d641bd 100644
--- a/tapsets.cxx
+++ b/tapsets.cxx
@@ -69,81 +69,6 @@ using namespace __gnu_cxx;
 
 
 // ------------------------------------------------------------------------
-// begin/end/error probes are run right during registration / deregistration
-// ------------------------------------------------------------------------
-
-static string TOK_BEGIN("begin");
-static string TOK_END("end");
-static string TOK_ERROR("error");
-
-enum be_t { BEGIN, END, ERROR };
-
-struct be_derived_probe: public derived_probe
-{
-  be_t type;
-  int64_t priority;
-
-  be_derived_probe (probe* p, probe_point* l, be_t t, int64_t pr):
-    derived_probe (p, l), type (t), priority (pr) {}
-
-  void join_group (systemtap_session& s);
-
-  static inline bool comp(be_derived_probe const *a,
-			  be_derived_probe const *b)
-  {
-    // This allows the BEGIN/END/ERROR probes to intermingle.
-    // But that's OK - they're always treversed with a nested
-    // "if (type==FOO)" conditional.
-    return a->priority < b->priority;
-  }
-
-  bool needs_global_locks () { return false; }
-  // begin/end probes don't need locks around global variables, since
-  // they aren't run concurrently with any other probes
-};
-
-
-struct be_derived_probe_group: public generic_dpg<be_derived_probe>
-{
-public:
-  void emit_module_decls (systemtap_session& s);
-  void emit_module_init (systemtap_session& s);
-  void emit_module_exit (systemtap_session& s);
-};
-
-struct be_builder: public derived_probe_builder
-{
-  be_t type;
-
-  be_builder(be_t t) : type(t) {}
-
-  virtual void build(systemtap_session &,
-		     probe * base,
-		     probe_point * location,
-		     literal_map_t const & parameters,
-		     vector<derived_probe *> & finished_results)
-  {
-    int64_t priority;
-    if ((type == BEGIN && !get_param(parameters, TOK_BEGIN, priority)) ||
-        (type == END && !get_param(parameters, TOK_END, priority)) ||
-        (type == ERROR && !get_param(parameters, TOK_ERROR, priority)))
-      priority = 0;
-    finished_results.push_back(
-	new be_derived_probe(base, location, type, priority));
-  }
-};
-
-
-void
-be_derived_probe::join_group (systemtap_session& s)
-{
-  if (! s.be_derived_probes)
-    s.be_derived_probes = new be_derived_probe_group ();
-  s.be_derived_probes->enroll (this);
-}
-
-
-// ------------------------------------------------------------------------
 void
 common_probe_entryfn_prologue (translator_output* o, string statestr,
                                string new_pp,
@@ -334,124 +259,6 @@ common_probe_entryfn_epilogue (translator_output* o,
 
 // ------------------------------------------------------------------------
 
-void
-be_derived_probe_group::emit_module_decls (systemtap_session& s)
-{
-  if (probes.empty()) return;
-
-  s.op->newline() << "/* ---- begin/end probes ---- */";
-  s.op->newline() << "static void enter_begin_probe (void (*fn)(struct context*), const char* pp) {";
-  s.op->indent(1);
-  common_probe_entryfn_prologue (s.op, "STAP_SESSION_STARTING", "pp", false);
-  s.op->newline() << "(*fn) (c);";
-  common_probe_entryfn_epilogue (s.op, false);
-  s.op->newline(-1) << "}";
-
-  s.op->newline() << "static void enter_end_probe (void (*fn)(struct context*), const char* pp) {";
-  s.op->indent(1);
-  common_probe_entryfn_prologue (s.op, "STAP_SESSION_STOPPING", "pp", false);
-  s.op->newline() << "(*fn) (c);";
-  common_probe_entryfn_epilogue (s.op, false);
-  s.op->newline(-1) << "}";
-
-  s.op->newline() << "static void enter_error_probe (void (*fn)(struct context*), const char* pp) {";
-  s.op->indent(1);
-  common_probe_entryfn_prologue (s.op, "STAP_SESSION_ERROR", "pp", false);
-  s.op->newline() << "(*fn) (c);";
-  common_probe_entryfn_epilogue (s.op, false);
-  s.op->newline(-1) << "}";
-
-  s.op->newline() << "static struct stap_be_probe {";
-  s.op->newline(1) << "void (*ph)(struct context*);";
-  s.op->newline() << "const char* pp;";
-  s.op->newline() << "int type;";
-  s.op->newline(-1) << "} stap_be_probes[] = {";
-  s.op->indent(1);
-
-  // NB: We emit the table in sorted order here, so we don't have to
-  // store the priority numbers as integers and sort at run time.
-
-  sort(probes.begin(), probes.end(), be_derived_probe::comp);
-
-  for (unsigned i=0; i < probes.size(); i++)
-    {
-      s.op->newline () << "{";
-      s.op->line() << " .pp="
-                   << lex_cast_qstring (*probes[i]->sole_location()) << ",";
-      s.op->line() << " .ph=&" << probes[i]->name << ",";
-      s.op->line() << " .type=" << probes[i]->type;
-      s.op->line() << " },";
-    }
-  s.op->newline(-1) << "};";
-}
-
-void
-be_derived_probe_group::emit_module_init (systemtap_session& s)
-{
-  if (probes.empty()) return;
-
-  s.op->newline() << "for (i=0; i<" << probes.size() << "; i++) {";
-  s.op->newline(1) << "struct stap_be_probe* stp = & stap_be_probes [i];";
-  s.op->newline() << "if (stp->type != " << BEGIN << ") continue;";
-  s.op->newline() << "enter_begin_probe (stp->ph, stp->pp);";
-  s.op->newline() << "/* rc = 0; */";
-  // NB: begin probes that cause errors do not constitute registration
-  // failures.  An error message will probably get printed and if
-  // MAXERRORS was left at 1, we'll get an stp_exit.  The
-  // error-handling probes will be run during the ordinary
-  // unregistration phase.
-  s.op->newline(-1) << "}";
-}
-
-void
-be_derived_probe_group::emit_module_exit (systemtap_session& s)
-{
-  if (probes.empty()) return;
-
-  s.op->newline() << "for (i=0; i<" << probes.size() << "; i++) {";
-  s.op->newline(1) << "struct stap_be_probe* stp = & stap_be_probes [i];";
-  s.op->newline() << "if (stp->type != " << END << ") continue;";
-  s.op->newline() << "enter_end_probe (stp->ph, stp->pp);";
-  s.op->newline(-1) << "}";
-
-  s.op->newline() << "for (i=0; i<" << probes.size() << "; i++) {";
-  s.op->newline(1) << "struct stap_be_probe* stp = & stap_be_probes [i];";
-  s.op->newline() << "if (stp->type != " << ERROR << ") continue;";
-  s.op->newline() << "enter_error_probe (stp->ph, stp->pp);";
-  s.op->newline(-1) << "}";
-}
-
-
-
-// ------------------------------------------------------------------------
-// never probes are never run
-// ------------------------------------------------------------------------
-
-static string TOK_NEVER("never");
-
-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 join_group (systemtap_session&) { /* thus no probe_group */ }
-};
-
-
-struct never_builder: public derived_probe_builder
-{
-  never_builder() {}
-  virtual void build(systemtap_session &,
-		     probe * base,
-		     probe_point * location,
-		     literal_map_t const &,
-		     vector<derived_probe *> & finished_results)
-  {
-    finished_results.push_back(new never_derived_probe(base, location));
-  }
-};
-
-
-
 // ------------------------------------------------------------------------
 //  Dwarf derived probes.  "We apologize for the inconvience."
 // ------------------------------------------------------------------------
@@ -6796,6 +6603,8 @@ itrace_derived_probe_group::emit_module_exit (systemtap_session& s)
 // utrace user-space probes
 // ------------------------------------------------------------------------
 
+static string TOK_BEGIN("begin");
+static string TOK_END("end");
 static string TOK_THREAD("thread");
 static string TOK_SYSCALL("syscall");
 
@@ -11177,17 +10986,9 @@ perfmon_derived_probe_group::emit_module_init (translator_output* o)
 void
 register_standard_tapsets(systemtap_session & s)
 {
+  register_tapset_been(s);
   register_tapset_timers(s);
 
-  s.pattern_root->bind(TOK_BEGIN)->bind(new be_builder(BEGIN));
-  s.pattern_root->bind_num(TOK_BEGIN)->bind(new be_builder(BEGIN));
-  s.pattern_root->bind(TOK_END)->bind(new be_builder(END));
-  s.pattern_root->bind_num(TOK_END)->bind(new be_builder(END));
-  s.pattern_root->bind(TOK_ERROR)->bind(new be_builder(ERROR));
-  s.pattern_root->bind_num(TOK_ERROR)->bind(new be_builder(ERROR));
-
-  s.pattern_root->bind(TOK_NEVER)->bind(new never_builder());
-
   s.pattern_root->bind("perfmon")->bind_str("counter")
     ->bind(new perfmon_builder());