Index: git-3-july/tapsets.cxx =================================================================== --- git-3-july.orig/tapsets.cxx +++ git-3-july/tapsets.cxx @@ -4929,7 +4929,302 @@ kprobe_builder::build(systemtap_session } } +// ------------------------------------------------------------------------ +// Hardware breakpoint based probes. +// ------------------------------------------------------------------------ + +static const string TOK_HWBKPT("data"); +static const string TOK_HWBKPT_WRITE("write"); +static const string TOK_HWBKPT_RW("rw"); + +#define HWBKPT_READ 0 +#define HWBKPT_WRITE 1 +#define HWBKPT_RW 2 +struct hwbkpt_derived_probe: public derived_probe +{ + hwbkpt_derived_probe (probe *base, + probe_point *location, + int64_t addr, + string symname, + bool has_only_read_access, + bool has_only_write_access, + bool has_rw_access + ); + Dwarf_Addr hwbkpt_addr; + string symbol_name; + unsigned int hwbkpt_access; + + void printsig (std::ostream &o) const; + void join_group (systemtap_session& s); +}; + +struct hwbkpt_derived_probe_group: public derived_probe_group +{ +private: + + vector hwbkpt_probes_vector; + typedef vector::iterator h_p_v_iterator; + +public: + void enroll (hwbkpt_derived_probe* probe); + void emit_module_decls (systemtap_session& s); + void emit_module_init (systemtap_session& s); + void emit_module_exit (systemtap_session& s); +}; + +hwbkpt_derived_probe::hwbkpt_derived_probe (probe *base, + probe_point *location, + int64_t addr, + string symname, + bool has_only_read_access, + bool has_only_write_access, + bool has_rw_access + ): + derived_probe (base, location), + hwbkpt_addr (addr), + symbol_name (symname) +{ + this->tok = base->tok; + + vector comps; + comps.push_back (new probe_point::component(TOK_KERNEL)); + + if (hwbkpt_addr) + comps.push_back (new probe_point::component (TOK_HWBKPT, new literal_number(hwbkpt_addr))); + else + if (symbol_name.size()) + comps.push_back (new probe_point::component (TOK_HWBKPT, new literal_string(symbol_name))); + + if (has_only_read_access) + this->hwbkpt_access = HWBKPT_READ ; +//TODO add code for comps.push_back for read, since this flag is not for x86 + + else + { + if (has_only_write_access) + { + this->hwbkpt_access = HWBKPT_WRITE ; + comps.push_back (new probe_point::component(TOK_HWBKPT_WRITE)); + } + else + { + this->hwbkpt_access = HWBKPT_RW ; + comps.push_back (new probe_point::component(TOK_HWBKPT_RW)); + } + } + + this->sole_location()->components = comps; +} + +void hwbkpt_derived_probe::printsig (ostream& o) const +{ + sole_location()->print (o); + printsig_nested (o); +} + +void hwbkpt_derived_probe::join_group (systemtap_session& s) +{ + if (! s.hwbkpt_derived_probes) + s.hwbkpt_derived_probes = new hwbkpt_derived_probe_group (); + s.hwbkpt_derived_probes->enroll (this); +} + +void hwbkpt_derived_probe_group::enroll (hwbkpt_derived_probe* p) +{ + hwbkpt_probes_vector.push_back (p); +} + +void +hwbkpt_derived_probe_group::emit_module_decls (systemtap_session& s) +{ + if (hwbkpt_probes_vector.empty()) return; + + s.op->newline() << "/* ---- hwbkpt-based probes ---- */"; + + // Warn of misconfigured kernels + s.op->newline() << "#ifndef CONFIG_HAVE_HW_BREAKPOINT"; + s.op->newline() << "#error \"Need CONFIG_HAVE_HW_BREAKPOINT!\""; + s.op->newline() << "#endif"; + + s.op->newline() << "#include "; + s.op->newline(); + +// Define macros for access type + s.op->newline() << "#define HWBKPT_READ 0"; + s.op->newline() << "#define HWBKPT_WRITE 1"; + s.op->newline() << "#define HWBKPT_RW 2"; + + // Forward declare the master entry functions + s.op->newline() << "static int enter_hwbkpt_probe (struct hw_breakpoint *inst,"; + s.op->line() << " struct pt_regs *regs);"; + + // Emit the actual probe list. + + s.op->newline() << "static struct hw_breakpoint "; + s.op->newline() << "stap_hwbkpt_probe_array[" << hwbkpt_probes_vector.size() << "];"; + + s.op->newline() << "static struct stap_hwbkpt_probe {"; + s.op->newline() << "int registered_p:1;"; +// registered_p = -1 signifies an invalid probe that must not be registered +// registered_p = 0 signifies a probe that failed registration +// registered_p = 1 signifies a probe that got registered successfully + + // Probe point & Symbol Names are mostly small and uniform enough + // to justify putting char[MAX]'s into the array instead of + // relocated char*'s. + + size_t pp_name_max = 0 , symbol_name_max = 0; + size_t pp_name_tot = 0 , symbol_name_tot = 0; + for (unsigned int it = 0; it < hwbkpt_probes_vector.size(); it++) + { + hwbkpt_derived_probe* p = hwbkpt_probes_vector.at(it); +#define DOIT(var,expr) do { \ + size_t var##_size = (expr) + 1; \ + var##_max = max (var##_max, var##_size); \ + var##_tot += var##_size; } while (0) + DOIT(pp_name, lex_cast_qstring(*p->sole_location()).size()); + DOIT(symbol_name, p->symbol_name.size()); +#undef DOIT + } + +#define CALCIT(var) \ + s.op->newline() << "const char " << #var << "[" << var##_name_max << "] ;"; + CALCIT(pp); + CALCIT(symbol); +#undef CALCIT + + s.op->newline() << "const unsigned long address;"; + s.op->newline() << "uint8_t atype;"; + s.op->newline() << "void (* const ph) (struct context*);"; + s.op->newline() << "} stap_hwbkpt_probes[] = {"; + s.op->indent(1); + + for (unsigned int it = 0; it < hwbkpt_probes_vector.size(); it++) + { + hwbkpt_derived_probe* p = hwbkpt_probes_vector.at(it); + s.op->newline() << "{"; + if (p->symbol_name.size()) + s.op->line() << " .address=(unsigned long)0x0" << "ULL,"; + else + s.op->line() << " .address=(unsigned long)0x" << hex << p->hwbkpt_addr << dec << "ULL,"; + s.op->line() << " .atype=" << p->hwbkpt_access << ","; + s.op->line() << " .pp=" << lex_cast_qstring (*p->sole_location()) << ","; + s.op->line() << " .symbol=\"" << p->symbol_name << "\","; + s.op->line() << " .ph=&" << p->name << ""; + s.op->line() << " },"; + } + s.op->newline(-1) << "};"; + + // Emit the hwbkpt callback function + s.op->newline(); + s.op->newline() << "static int enter_hwbkpt_probe (struct hw_breakpoint *inst,"; + s.op->line() << " struct pt_regs *regs) {"; + s.op->newline(1) << "int hwbkpt_probe_idx = ((uintptr_t)inst-(uintptr_t)stap_hwbkpt_probe_array)/sizeof(struct hw_breakpoint);"; + + // Check that the index is plausible + s.op->newline() << "struct stap_hwbkpt_probe *sdp = &stap_hwbkpt_probes["; + s.op->line() << "((hwbkpt_probe_idx >= 0 && hwbkpt_probe_idx < " << hwbkpt_probes_vector.size() << ")?"; + s.op->line() << "hwbkpt_probe_idx:0)"; // NB: at least we avoid memory corruption + s.op->line() << "];"; + common_probe_entryfn_prologue (s.op, "STAP_SESSION_RUNNING", "sdp->pp"); + s.op->newline() << "c->regs = regs;"; + s.op->newline() << "(*sdp->ph) (c);"; + common_probe_entryfn_epilogue (s.op); + s.op->newline() << "return 0;"; + s.op->newline(-1) << "}"; +} + +void +hwbkpt_derived_probe_group::emit_module_init (systemtap_session& s) +{ + s.op->newline() << "for (i=0; i<" << hwbkpt_probes_vector.size() << "; i++) {"; + s.op->newline(1) << "struct stap_hwbkpt_probe *sdp = & stap_hwbkpt_probes[i];"; + s.op->newline() << "struct hw_breakpoint *hp = & stap_hwbkpt_probe_array[i];"; + s.op->newline() << "void *addr = (void *) sdp->address;"; + s.op->newline() << "const char *hwbkpt_symbol_name = addr ? NULL : sdp->symbol;"; + s.op->newline() << " hp->info.name = (char *) hwbkpt_symbol_name;"; + s.op->newline() << " hp->info.address = (unsigned long) addr;"; + s.op->newline() << "#ifdef CONFIG_X86"; + s.op->newline() << " hp->info.len = HW_BREAKPOINT_LEN_1;"; + s.op->newline() << " switch(sdp->atype)"; + s.op->newline() << " {"; + s.op->newline() << " case HWBKPT_READ:"; + s.op->newline() << " _stp_warn(\"Probe %s registration skipped : READ-ONLY hardware breakpoints not supported on x86\",sdp->pp);"; + s.op->newline() << " sdp->registered_p = -1;"; + s.op->newline() << " case HWBKPT_WRITE:"; + s.op->newline() << " hp->info.type = HW_BREAKPOINT_WRITE;"; + s.op->newline() << " case HWBKPT_RW:"; + s.op->newline() << " hp->info.type = HW_BREAKPOINT_RW;"; + s.op->newline() << " }"; + s.op->newline() << "#endif /*CONFIG_X86*/"; + s.op->newline() << "hp->triggered = (void *)&enter_hwbkpt_probe;"; + s.op->newline() << "probe_point = sdp->pp;"; // for error messages + s.op->newline() << "if (sdp->registered_p >= 0)"; + s.op->newline() << "{"; + s.op->newline() << " rc = register_kernel_hw_breakpoint(hp);"; + s.op->newline() << " if (rc < 0) {"; + s.op->newline() << " sdp->registered_p = 0;"; + s.op->newline(1) << " _stp_warn(\" Hwbkpt Probe %s : Registration error (rc = %d), Addr = %u, name = %s\",probe_point,rc,hp->info.address,hp->info.name);"; + s.op->newline(-1) << " }"; + s.op->newline() << " else sdp->registered_p = 1;"; + s.op->newline() << "}"; + s.op->newline(-1) << "}"; // for loop +} +void +hwbkpt_derived_probe_group::emit_module_exit (systemtap_session& s) +{ + //Unregister hwbkpt probes. + s.op->newline() << "for (i=0; i<" << hwbkpt_probes_vector.size() << "; i++) {"; + s.op->newline(1) << "struct stap_hwbkpt_probe *sdp = & stap_hwbkpt_probes[i];"; + s.op->newline() << "struct hw_breakpoint *hp = & stap_hwbkpt_probe_array[i];"; + s.op->newline() << "if (! sdp->registered_p) continue;"; + s.op->newline() << " unregister_kernel_hw_breakpoint(hp);"; + s.op->newline() << "sdp->registered_p = 0;"; + s.op->newline(-1) << "}"; +} + +struct hwbkpt_builder: public derived_probe_builder +{ + hwbkpt_builder() {} + virtual void build(systemtap_session & sess, + probe * base, + probe_point * location, + literal_map_t const & parameters, + vector & finished_results); +}; + +void +hwbkpt_builder::build(systemtap_session & sess, + probe * base, + probe_point * location, + literal_map_t const & parameters, + vector & finished_results) +{ + string symbol_str_val; + int64_t hwbkpt_address; + bool has_addr, has_symbol_str, has_write, has_rw; + + has_addr = get_param (parameters, TOK_HWBKPT, hwbkpt_address); + has_symbol_str = get_param (parameters, TOK_HWBKPT, symbol_str_val); + has_write = (parameters.find(TOK_HWBKPT_WRITE) != parameters.end()); + has_rw = (parameters.find(TOK_HWBKPT_RW) != parameters.end()); + + if (has_addr) + finished_results.push_back (new hwbkpt_derived_probe (base, + location, + hwbkpt_address, + "",0, + has_write, + has_rw)); + else // has symbol_str + finished_results.push_back (new hwbkpt_derived_probe (base, + location, + 0, + symbol_str_val,0, + has_write, + has_rw)); +} // ------------------------------------------------------------------------ // statically inserted kernel-tracepoint derived probes @@ -5487,7 +5782,7 @@ tracepoint_derived_probe_group::emit_mod } s.op->line() << ") {"; s.op->indent(1); - common_probe_entryfn_prologue (s.op, "STAP_SESSION_RUNNING", + common_probe_entryfn_prologue (s.op, "STAP_SESSION_RUNNING", lex_cast_qstring (*p->sole_location())); s.op->newline() << "c->marker_name = " << lex_cast_qstring (p->tracepoint_name) @@ -5732,7 +6027,6 @@ tracepoint_builder::init_dw(systemtap_se return true; } - void tracepoint_builder::build(systemtap_session& s, probe *base, probe_point *location, @@ -5750,7 +6044,6 @@ tracepoint_builder::build(systemtap_sess } - // ------------------------------------------------------------------------ // Standard tapset registry. // ------------------------------------------------------------------------ @@ -5798,6 +6091,16 @@ register_standard_tapsets(systemtap_sess ->bind_num(TOK_MAXACTIVE)->bind(new kprobe_builder()); s.pattern_root->bind(TOK_KPROBE)->bind_num(TOK_STATEMENT) ->bind(TOK_ABSOLUTE)->bind(new kprobe_builder()); + + //Hwbkpt based probe + s.pattern_root->bind(TOK_KERNEL)->bind_num(TOK_HWBKPT) + ->bind(TOK_HWBKPT_WRITE)->bind(new hwbkpt_builder()); + s.pattern_root->bind(TOK_KERNEL)->bind_str(TOK_HWBKPT) + ->bind(TOK_HWBKPT_WRITE)->bind(new hwbkpt_builder()); + s.pattern_root->bind(TOK_KERNEL)->bind_num(TOK_HWBKPT) + ->bind(TOK_HWBKPT_RW)->bind(new hwbkpt_builder()); + s.pattern_root->bind(TOK_KERNEL)->bind_str(TOK_HWBKPT) + ->bind(TOK_HWBKPT_RW)->bind(new hwbkpt_builder()); } @@ -5824,6 +6127,7 @@ all_session_groups(systemtap_session& s) DOONE(mark); DOONE(tracepoint); DOONE(kprobe); + DOONE(hwbkpt); DOONE(hrtimer); DOONE(perfmon); DOONE(procfs);