From fced4ba337a4eddb4163994834a122e62c6efdfb Mon Sep 17 00:00:00 2001 From: Ravi Bangoria Date: Wed, 14 Sep 2016 13:32:51 +0530 Subject: [PATCH 1/2] ppc64le: Store correct function entry address in symbol_table PPC64 ELF ABI v2 has a Global Entry Point and a Local Entry Point for the functions. Debuginfo of ELF contains GEP which is same as entrypc while symbol table contains GEP and offset, from which we can calculate LEP. LEP is used to call function within single CU, when TOC pointer update is not required. Placing a probe on LEP catches call from both the GEP and the LEP but, by default, systemtap probes on GEP. For ppc64le, Systemtap stores LEP in symbol table and prioritize symbol table over debuginfo. But, storing LEP in symbol table has couple of regression effect. As LEP is only required at a time of adding a probe, don't store it in symbol table. No need to prioritize symbol table as well because debuginfo and symbol table both will contain Global Entry Point. Revert commit b4c6a4b1cd00 ("Prioritize symbol table lookup for ppc64le") partially. Signed-off-by: Ravi Bangoria --- tapsets.cxx | 62 +------------------------------------------------------------ 1 file changed, 1 insertion(+), 61 deletions(-) diff --git a/tapsets.cxx b/tapsets.cxx index 4167678..a887e1f 100644 --- a/tapsets.cxx +++ b/tapsets.cxx @@ -2134,18 +2134,6 @@ query_dwarf_inline_instance (Dwarf_Die * die, dwarf_query * q) } } -static bool -is_filtered_func_exists (func_info_map_t const& filtered, func_info *fi) -{ - for (unsigned i = 0; i < filtered.size(); i++) - { - if ((filtered[i].entrypc == fi->entrypc) && (filtered[i].name == fi->name)) - return true; - } - - return false; -} - static int query_dwarf_func (Dwarf_Die * func, dwarf_query * q) { @@ -2198,37 +2186,7 @@ query_dwarf_func (Dwarf_Die * func, dwarf_query * q) q->dw.function_line (&func.decl_line); Dwarf_Addr entrypc; - - func.entrypc = 0; - Dwarf_Addr bias; - Dwfl_Module *mod = q->dw.module; - Elf* elf = (dwarf_getelf (dwfl_module_getdwarf (mod, &bias)) - ?: dwfl_module_getelf (mod, &bias)); - - GElf_Ehdr ehdr_mem; - GElf_Ehdr* em = gelf_getehdr (elf, &ehdr_mem); - if (em == NULL) throw SEMANTIC_ERROR (_("Couldn't get elf header")); - - /* Giving priority to sym_table for ppc64*/ - if ((em->e_machine == EM_PPC64) && ((em->e_flags & EF_PPC64_ABI) == 2) - && (q->dw.mod_info->sym_table)) - { - /* The linkage name is the best match for the symbol table. */ - const string& linkage_name = dwarf_linkage_name(&func.die) - ?: dwarf_diename(&func.die) ?: (string)func.name; - - set fis = q->dw.mod_info->sym_table->lookup_symbol(linkage_name); - for (set::iterator it=fis.begin(); it!=fis.end() ; ++it) - { - func.entrypc = (*it)->entrypc; - if (is_filtered_func_exists(q->filtered_functions, &func)) - continue; - q->filtered_functions.push_back(func); - } - } - - /* If not ppc64 or not found in sym_table, try it directly. */ - if (!func.entrypc && q->dw.function_entrypc (&entrypc)) + if (q->dw.function_entrypc (&entrypc)) { func.entrypc = entrypc; q->filtered_functions.push_back (func); @@ -8448,13 +8406,6 @@ symbol_table::get_from_elf() int syments = dwfl_module_getsymtab(mod); assert(syments); prepare_section_rejection(mod); - Dwarf_Addr bias; - Elf* elf = (dwarf_getelf (dwfl_module_getdwarf (mod, &bias)) - ?: dwfl_module_getelf (mod, &bias)); - - GElf_Ehdr ehdr_mem; - GElf_Ehdr* em = gelf_getehdr (elf, &ehdr_mem); - if (em == NULL) throw SEMANTIC_ERROR (_("Couldn't get elf header")); for (int i = 1; i < syments; ++i) { @@ -8487,18 +8438,7 @@ symbol_table::get_from_elf() continue; interned_string name = n; - /* - * For ELF ABI v2 on PPC64 LE, we need to adjust sym.st_value corresponding - * to the bits of sym.st_other. These bits will tell us what's the offset - * of the local entry point from the global entry point. - * - * st_other field is currently only used with ABIv2 on ppc64 - */ Dwarf_Addr entrypc = addr; - if ((em->e_machine == EM_PPC64) && ((em->e_flags & EF_PPC64_ABI) == 2) - && (GELF_ST_TYPE(sym.st_info) == STT_FUNC) && sym.st_other) - entrypc += PPC64_LOCAL_ENTRY_OFFSET(sym.st_other); - if (GELF_ST_TYPE(sym.st_info) == STT_FUNC) add_symbol(name, (GELF_ST_BIND(sym.st_info) == STB_WEAK), reject, addr, entrypc); -- 1.8.3.1 From 1b83a55a0272f2eb0bdcd5809fb630e1f369d400 Mon Sep 17 00:00:00 2001 From: Ravi Bangoria Date: Wed, 14 Sep 2016 13:36:00 +0530 Subject: [PATCH 2/2] ppc64le: Fix LEP usage for probing PPC64 ELF ABI v2 has a Global Entry Point and a Local Entry Point for the functions. Debuginfo of ELF contains GEP which is same as entrypc while symbol table contains GEP and offset, from which we can calculate LEP. LEP is used to call function within single CU, when TOC pointer update is not required. Placing a probe on LEP catches call from both the GEP and the LEP but, by default, systemtap probes on GEP. Commit b4c6a4b1cd00 ("Prioritize symbol table lookup for ppc64le") solve this issue by storing LEP in symbol table and prioritizing symbol table over debuginfo for ppc64le. But there are few regression effect of this patch. Couple of examples are given below. 1. If target program is compiled without optimization and user is interested in function parameter, systemtap should probe after function prologue. But above patch forces probe on LEP and which result in garbage value of function parameter will get recorded. $ make verbose=1 installcheck RUNTESTFLAGS='at_var.exp -v --debug' ... # of expected passes 1 # of unexpected failures 1 2. Probe on shared library function with parameter is failing at Pass 2. $ make verbose=1 installcheck RUNTESTFLAGS='exelib.exp -v --debug' ... # of expected passes 10 # of unexpected failures 64 3. When symbol_name with offset is used to register kprobe, kernel itself will find LEP and adds offset to it. Systemtap using LEP to find offset is resulting in offset being added two times. GEP + lep_offset (by systemtap) + lep_offset (by kernel) This can be solved by calculating LEP only at a time of adding a probe. That will make effect of LEP local to that area and won't have any regression effect. After applying patch: $ make verbose=1 installcheck RUNTESTFLAGS='at_var.exp -v --debug' ... # of expected passes 2 $ make verbose=1 installcheck RUNTESTFLAGS='exelib.exp -v --debug' ... # of expected passes 74 Signed-off-by: Ravi Bangoria --- tapsets.cxx | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 59 insertions(+), 1 deletion(-) diff --git a/tapsets.cxx b/tapsets.cxx index a887e1f..30aebb9 100644 --- a/tapsets.cxx +++ b/tapsets.cxx @@ -1376,6 +1376,59 @@ string path_remove_sysroot(const systemtap_session& sess, const string& path) return retval; } +/* + * Convert 'Global Entry Point' to 'Local Entry Point'. + * + * if @gep contains next address after prologue, don't change it. + * + * For ELF ABI v2 on PPC64 LE, we need to adjust sym.st_value corresponding + * to the bits of sym.st_other. These bits will tell us what's the offset + * of the local entry point from the global entry point. + * + * st_other field is currently only used with ABIv2 on ppc64 + */ +static Dwarf_Addr +get_lep(dwarf_query *q, Dwarf_Addr gep) +{ + Dwarf_Addr bias; + Dwfl_Module *mod = q->dw.module; + Elf* elf = (dwarf_getelf (dwfl_module_getdwarf (mod, &bias)) + ?: dwfl_module_getelf (mod, &bias)); + + GElf_Ehdr ehdr_mem; + GElf_Ehdr* em = gelf_getehdr (elf, &ehdr_mem); + if (em == NULL) + throw SEMANTIC_ERROR (_("Couldn't get elf header")); + + if (!(em->e_machine == EM_PPC64) || !((em->e_flags & EF_PPC64_ABI) == 2)) + return gep; + + int syments = dwfl_module_getsymtab(mod); + for (int i = 1; i < syments; ++i) + { + GElf_Sym sym; + GElf_Word section; + GElf_Addr addr; + +#if _ELFUTILS_PREREQ (0, 158) + dwfl_module_getsym_info (mod, i, &sym, &addr, §ion, NULL, NULL); +#else + dwfl_module_getsym (mod, i, &sym, §ion); + addr = sym.st_value; +#endif + + /* + * Symbol table contains module_bias + offset. Substract module_bias + * to compare offset with gep. + */ + if ((addr - bias) == gep && (GELF_ST_TYPE(sym.st_info) == STT_FUNC) + && sym.st_other) + return gep + PPC64_LOCAL_ENTRY_OFFSET(sym.st_other); + } + + return gep; +} + void dwarf_query::add_probe_point(interned_string dw_funcname, interned_string filename, @@ -1384,12 +1437,14 @@ dwarf_query::add_probe_point(interned_string dw_funcname, Dwarf_Addr addr) { interned_string reloc_section; // base section for relocation purposes + Dwarf_Addr orig_addr = addr; Dwarf_Addr reloc_addr; // relocated interned_string module = dw.module_name; // "kernel" or other interned_string funcname = dw_funcname; assert (! has_absolute); // already handled in dwarf_builder::build() + addr = get_lep(this, addr); reloc_addr = dw.relocate_address(addr, reloc_section); // If we originally used the linkage name, then let's call it that way @@ -1455,7 +1510,10 @@ dwarf_query::add_probe_point(interned_string dw_funcname, symbol_table *sym_table = mi->sym_table; func_info *symbol = sym_table->get_func_containing_address(addr); - Dwarf_Addr offset = addr - symbol->addr; + + // Do not use LEP to find offset here. When 'symbol_name' + // is used to register probe, kernel itself will find LEP. + Dwarf_Addr offset = orig_addr - symbol->addr; results.push_back (new dwarf_derived_probe(funcname, filename, line, module, reloc_section, addr, -- 1.8.3.1