/* -*- linux-c -*-
* Symbolic Lookup Functions
* Copyright (C) 2005-2018 Red Hat Inc.
* Copyright (C) 2006 Intel Corporation.
*
* This file is part of systemtap, and is free software. You can
* redistribute it and/or modify it under the terms of the GNU General
* Public License (GPL); either version 2, or (at your option) any
* later version.
*/
#ifndef _STP_SYM_C_
#define _STP_SYM_C_
#include "sym.h"
#include "vma.c"
#include "stp_string.c"
#ifdef STP_NEED_LINE_DATA
#include "unwind/unwind.h"
#endif
#include <asm/unaligned.h>
#include <asm/uaccess.h>
#include <linux/list.h>
#include <linux/module.h>
#ifdef STAPCONF_PROBE_KERNEL
#include <linux/uaccess.h>
#endif
/* Returns absolute address of offset into kernel module/section.
Returns zero when module and section couldn't be found
(aren't in memory yet). */
static unsigned long _stp_kmodule_relocate(const char *module,
const char *section,
unsigned long offset)
{
unsigned i, j;
dbug_sym(1, "%s, %s, %lx\n", module, section, offset);
/* absolute, unrelocated address */
if (!module || !strcmp(section, "")
||_stp_num_modules == 0) {
return offset;
}
for (i = 0; i < _stp_num_modules; i++) {
struct _stp_module *m = _stp_modules[i];
if (strcmp(module, m->name)) /* duplication apprx. not possible for kernel */
continue;
for (j = 0; j < m->num_sections; j++) {
struct _stp_section *s = &m->sections[j];
if (!strcmp(section, s->name)) {
/* mod and sec name match. tsk should match dynamic/static. */
if (s->static_addr != 0) {
unsigned long addr = offset + s->static_addr;
dbug_sym(1, "address=%lx\n", addr);
return addr;
} else {
/* static section, not in memory yet? */
dbug_sym(1, "section %s, not in memory yet?", s->name);
return 0;
}
}
}
}
return 0;
}
static unsigned long _stp_umodule_relocate(const char *path,
unsigned long offset,
struct task_struct *tsk)
{
unsigned i;
unsigned long vm_start = 0;
dbug_sym(1, "[%d] %s, %lx\n", tsk->pid, path, offset);
for (i = 0; i < _stp_num_modules; i++) {
struct _stp_module *m = _stp_modules[i];
if (strcmp(path, m->path)
|| m->num_sections != 1)
continue;
if (!strcmp(m->sections[0].name, ".absolute"))
return offset;
if (strcmp(m->sections[0].name, ".dynamic"))
continue;
if (stap_find_vma_map_info_user(tsk->group_leader, m,
&vm_start, NULL, NULL) == 0) {
offset += vm_start;
dbug_sym(1, "address=%lx\n", offset);
return offset;
}
}
return 0;
}
/* Return (kernel) module owner and, if sec != NULL, fills in closest
section of the address if found, return NULL otherwise. */
static struct _stp_module *_stp_kmod_sec_lookup(unsigned long addr,
struct _stp_section **sec)
{
unsigned midx = 0;
for (midx = 0; midx < _stp_num_modules; midx++)
{
unsigned secidx;
for (secidx = 0; secidx < _stp_modules[midx]->num_sections; secidx++)
{
unsigned long sec_addr;
unsigned long sec_size;
sec_addr = _stp_modules[midx]->sections[secidx].static_addr;
sec_size = _stp_modules[midx]->sections[secidx].size;
if (addr >= sec_addr && addr < sec_addr + sec_size)
{
if (sec)
*sec = & _stp_modules[midx]->sections[secidx];
return _stp_modules[midx];
}
}
}
return NULL;
}
/* Return (user) module in which the the given addr falls. Returns
NULL when no module can be found that contains the addr. Fills in
vm_start (addr where module is mapped in) and (base) name of module
when given. Note that user modules always have exactly one section
(.dynamic or .absolute). */
static struct _stp_module *_stp_umod_lookup(unsigned long addr,
struct task_struct *task,
const char **name,
unsigned long *vm_start,
unsigned long *vm_end)
{
void *user = NULL;
#ifdef CONFIG_COMPAT
/* Handle 32bit signed values in 64bit longs, chop off top bits. */
if (test_tsk_thread_flag(task, TIF_32BIT))
addr &= ((compat_ulong_t) ~0);
#endif
if (stap_find_vma_map_info(task->group_leader, addr,
vm_start, vm_end, name, &user) == 0)
if (user != NULL)
{
struct _stp_module *m = (struct _stp_module *)user;
dbug_sym(1, "found module %s at 0x%lx\n", m->path,
vm_start ? *vm_start : 0);
return m;
}
return NULL;
}
static const char *_stp_kallsyms_lookup(unsigned long addr,
unsigned long *symbolsize,
unsigned long *offset,
const char **modname,
/* char ** secname? */
struct task_struct *task)
{
struct _stp_module *m = NULL;
struct _stp_section *sec = NULL;
struct _stp_symbol *s = NULL;
unsigned end, begin = 0;
unsigned long rel_addr = 0;
if (addr == 0)
return NULL;
if (task)
{
unsigned long vm_start = 0;
unsigned long vm_end = 0;
#ifdef CONFIG_COMPAT
/* Handle 32bit signed values in 64bit longs, chop off top bits.
_stp_umod_lookup does the same, but we need it here for the
binary search on addr below. */
if (test_tsk_thread_flag(task, TIF_32BIT))
addr &= ((compat_ulong_t) ~0);
#endif
m = _stp_umod_lookup(addr, task, modname, &vm_start, &vm_end);
if (m)
{
sec = &m->sections[0];
/* XXX .absolute sections really shouldn't be here... */
if (strcmp(".dynamic", m->sections[0].name) == 0)
rel_addr = addr - vm_start;
else
rel_addr = addr;
}
if (modname && *modname)
{
/* In case no symbol is found, fill in based on module. */
if (offset)
*offset = addr - vm_start;
if (symbolsize)
*symbolsize = vm_end - vm_start;
}
}
else
{
m = _stp_kmod_sec_lookup(addr, &sec);
if (m)
{
rel_addr = addr - sec->static_addr;
if (modname)
*modname = m->name;
}
}
if (unlikely (m == NULL || sec == NULL))
return NULL;
/* NB: relativize the address to the section. */
addr = rel_addr;
end = sec->num_symbols;
/* binary search for symbols within the module */
do {
unsigned mid = (begin + end) / 2;
if (addr < sec->symbols[mid].addr)
end = mid;
else
begin = mid;
} while (begin + 1 < end);
/* result index in $begin */
s = & sec->symbols[begin];
if (likely(addr >= s->addr)) {
if (offset)
*offset = addr - s->addr;
/* We could also pass sec->name here. */
if (symbolsize) {
if ((begin + 1) < sec->num_symbols)
*symbolsize = sec->symbols[begin + 1].addr - s->addr;
else
*symbolsize = 0;
// NB: This is only a heuristic. Sometimes there are large
// gaps between text areas of modules.
}
return s->symbol;
}
return NULL;
}
#ifdef STP_NEED_LINE_DATA
static void _stp_filename_lookup(struct _stp_module *mod, char ** filename,
uint8_t *dirsecp, uint8_t *enddirsecp,
unsigned fileidx, int user, int compat_task)
{
uint8_t *linep = dirsecp;
static char fullpath [MAXSTRINGLEN];
char *dirname_entry = NULL, *filename_entry = NULL;
unsigned diridx = 0, i, j;
// skip past the directory table in the debug_line info
while (*linep != 0 && linep < enddirsecp)
{
char *entry = (char *) linep;
uint8_t *endnamep = (uint8_t *) memchr (entry, '\0', (size_t) (enddirsecp-linep));
if (endnamep == NULL || (endnamep + 1) > enddirsecp)
return;
linep = endnamep + 1;
}
if ((char) linep[0] != '\0')
return;
++linep;
// at the filename table
for (i = 1; *linep != 0 && linep < enddirsecp; ++i)
{
uint8_t *endnamep = NULL;
filename_entry = (char *) linep;
endnamep = (uint8_t *) memchr (filename_entry, '\0', (size_t) (enddirsecp-linep));
if (endnamep == NULL || (endnamep + 1) > enddirsecp)
return;
// move the line pointer past the file name. account for the null byte
linep = endnamep + 1;
// save the directory index
diridx = read_pointer ((const uint8_t **) &linep, enddirsecp, DW_EH_PE_leb128, user, compat_task);
if (linep > enddirsecp)
return;
if (i == fileidx)
break;
filename_entry = NULL;
// modification time
read_pointer ((const uint8_t **) &linep, enddirsecp, DW_EH_PE_leb128, user, compat_task);
// length of a file
read_pointer ((const uint8_t **) &linep, enddirsecp, DW_EH_PE_leb128, user, compat_task);
// check that nothing went wrong with reading the ulebs
if (linep > enddirsecp)
return;
}
if (filename_entry == NULL)
return; // return just the linenumber
// if dirid == 0, it's the compilation directory. otherwise retrieve the
// directory path if the file path was relative
if (diridx != 0 && filename_entry[0] != '/')
{
linep = dirsecp;
for (j = 1; *linep != 0 && linep < enddirsecp; j++)
{
uint8_t *endnamep = NULL;
dirname_entry = (char *) linep;
endnamep = (uint8_t *) memchr (dirname_entry, '\0', (size_t) (enddirsecp-linep));
if (endnamep == NULL || (endnamep + 1) > enddirsecp)
return;
if (j == diridx)
break;
dirname_entry = NULL;
linep = endnamep + 1;
}
if (dirname_entry == NULL)
return;
}
// bring it all together
// the filename was the full path
if (filename_entry[0] == '/')
*filename = filename_entry;
// relative filename, and the dir corresponds to the compilation dir
else if (diridx == 0)
{
char *slash = strrchr (mod->path, '/');
strlcpy(fullpath, mod->path, (size_t) (2 + slash - mod->path));
strlcat(fullpath, filename_entry, MAXSTRINGLEN);
*filename = fullpath;
}
// relative filename and a directory from the table in the debug line data
else
{
strlcpy(fullpath, dirname_entry, MAXSTRINGLEN);
strlcat(fullpath, "/", MAXSTRINGLEN);
strlcat(fullpath, filename_entry, MAXSTRINGLEN);
*filename = fullpath;
}
}
#endif /* STP_NEED_LINE_DATA */
unsigned long _stp_linenumber_lookup(unsigned long addr, struct task_struct *task, char ** filename, int need_filename)
{
struct _stp_module *m;
struct _stp_section *sec;
const char *modname = NULL;
uint8_t *linep, *enddatap;
int compat_task = _stp_is_compat_task();
int user = (task ? 1 : 0);
// the portion below is encased in this conditional because some of the functions
// and constants needed are encased in a similar condition
#ifdef STP_NEED_LINE_DATA
if (addr == 0)
return 0;
if (task)
{
unsigned long vm_start = 0;
unsigned long vm_end = 0;
#ifdef CONFIG_COMPAT
/* Handle 32bit signed values in 64bit longs, chop off top bits. */
if (test_tsk_thread_flag(task, TIF_32BIT))
addr &= ((compat_ulong_t) ~0);
#endif
m = _stp_umod_lookup(addr, task, &modname, &vm_start, &vm_end);
}
else
m = _stp_kmod_sec_lookup(addr, &sec);
if (m == NULL || m->debug_line == NULL)
return 0;
// if addr is a kernel address, it will need to be adjusted
if (!task)
{
int i;
unsigned long offset = 0;
// have to factor in the load_offset of (specifically) the .text section
for (i=0; i<m->num_sections; i++)
if (!strcmp(m->sections[i].name, ".text"))
{
offset = (m->sections[i].static_addr - m->sections[i].sec_load_offset);
break;
}
if (addr < offset)
return 0;
addr = addr - offset;
}
linep = m->debug_line;
enddatap = m->debug_line + m->debug_line_len;
while (linep < enddatap)
{
// State machine "curr" values are updated directly.
// A "row" is committed line data that we should compare against, only
// updated for DW_LNS_copy, DW_LNE_end_sequence, and special opcodes.
uint64_t curr_addr = 0, row_addr = 0;
unsigned int curr_file_idx = 1, row_file_idx = 1;
unsigned long curr_linenum = 1, row_linenum = 1;
unsigned int row_end_sequence = 1;
unsigned int length = 4;
unsigned int skip_to_seq_end = 0, op_index = 0;
uint64_t unit_length, hdr_length;
uint8_t *endunitp, *endhdrp, *dirsecp, *stdopcode_lens_secp;
uint16_t version;
uint8_t opcode_base, line_range, min_instr_len = 0, max_ops = 1;
int8_t line_base;
unit_length = (uint64_t) read_pointer ((const uint8_t **) &linep, enddatap, DW_EH_PE_data4, user, compat_task);
if (unit_length == 0xffffffff)
{
if (unlikely (linep + 8 > enddatap))
return 0;
unit_length = (uint64_t) read_pointer ((const uint8_t **) &linep, enddatap, DW_EH_PE_data8, user, compat_task);
length = 8;
}
if (unit_length < (length + 2) || (linep + unit_length) > enddatap)
return 0;
endunitp = linep + unit_length;
version = read_pointer ((const uint8_t **) &linep, endunitp, DW_EH_PE_data2, user, compat_task);
if (length == 4)
hdr_length = (uint64_t) read_pointer ((const uint8_t **) &linep, endunitp, DW_EH_PE_data4, user, compat_task);
else
hdr_length = (uint64_t) read_pointer ((const uint8_t **) &linep, endunitp, DW_EH_PE_data8, user, compat_task);
if ((linep + hdr_length) > endunitp || hdr_length < (version >= 4 ? 6 : 5))
return 0;
endhdrp = linep + hdr_length;
// minimum instruction length
min_instr_len = *linep++;
// max operations per instruction
if (version >= 4)
{
max_ops = *linep++;
if (max_ops == 0)
return 0; // max operations per instruction is supposed to > 0;
}
// default value of the is_stmt register
++linep;
// line base. this is a signed value.
line_base = *linep++;
// line range
line_range = *linep++;
if (line_range == 0)
return 0;
// opcode base
opcode_base = *linep++;
// opcodes
stdopcode_lens_secp = linep - 1;
// need this check if the header length check covers this region?
if ((linep + opcode_base - 1) >= endhdrp)
return 0;
linep += opcode_base - 1;
// at the directory table. don't need an other information from the header
// in order to find the desired line number, so we will save a pointer to
// this point and skip ahead to the end of the header. this portion of the
// header will be visited again after a line number has been found if a
// filename is needed.
dirsecp = linep;
linep = endhdrp;
// iterating through the opcodes. will deal with three defined types of
// opcode: special, extended and standard. there is also a portion at
// the end of this loop that will deal with unknown (standard) opcodes.
while (linep < endunitp)
{
uint8_t opcode = *linep++;
long addr_adv = 0;
unsigned int commit_row = 0;
unsigned int end_sequence = 0;
if (opcode >= opcode_base) // special opcode
{
// line range was checked before this point. this variable is not altered after it is initialized.
curr_linenum += (line_base + ((opcode - opcode_base) % line_range));
addr_adv = ((opcode - opcode_base) / line_range);
commit_row = 1;
}
else if (opcode == 0) // extended opcode
{
int len;
uint8_t subopcode;
if (linep + 1 > endunitp)
return 0;
len = *linep++;
if (linep + len > endunitp || len < 1)
return 0;
subopcode = *linep++; // the sub opcode
switch (subopcode)
{
case DW_LNE_end_sequence:
// NB: we don't clear "curr" values until after the row is compared.
op_index = 0;
skip_to_seq_end = 0;
end_sequence = 1;
commit_row = 1;
break;
case DW_LNE_set_address:
if ((len - 1) == 4) // account for the opcode (the -1)
curr_addr = (uint64_t) read_pointer ((const uint8_t **) &linep, endunitp, DW_EH_PE_data4, user, compat_task);
else if ((len - 1) == 8)
curr_addr = (uint64_t) read_pointer ((const uint8_t **) &linep, endunitp, DW_EH_PE_data8, user, compat_task);
else
return 0;
// if the set address is past the address we want, iterate
// to the end of the sequence without doing more address
// and linenumber calcs than necessary
if (curr_addr > addr)
skip_to_seq_end = 1;
op_index = 0;
break;
default: // advance the ptr by the specified amount
linep += len-1;
break;
}
}
else if (opcode <= DW_LNS_set_isa) // known standard opcode
{
uint8_t *linep_before = linep;
switch (opcode)
{
case DW_LNS_copy:
commit_row = 1;
break;
case DW_LNS_advance_pc:
addr_adv = read_pointer ((const uint8_t **) &linep, endunitp, DW_EH_PE_leb128, user, compat_task);
break;
case DW_LNS_fixed_advance_pc:
addr_adv = read_pointer ((const uint8_t **) &linep, endunitp, DW_EH_PE_data2, user, compat_task);
if (linep_before == linep) // the read failed
return 0;
op_index = 0;
break;
case DW_LNS_advance_line:
curr_linenum += read_pointer ((const uint8_t **) &linep, endunitp, DW_EH_PE_leb128+DW_EH_PE_signed, user, compat_task);
break;
case DW_LNS_set_file:
curr_file_idx = read_pointer ((const uint8_t **) &linep, endunitp, DW_EH_PE_leb128, user, compat_task);
break;
case DW_LNS_set_column:
read_pointer ((const uint8_t **) &linep, endunitp, DW_EH_PE_leb128, user, compat_task);
break;
case DW_LNS_const_add_pc:
addr_adv = ((255 - opcode_base) / line_range);
break;
case DW_LNS_set_isa:
read_pointer ((const uint8_t **) &linep, endunitp, DW_EH_PE_leb128, user, compat_task);
break;
}
if (linep > endunitp) // reading in the leb128 failed
return 0;
}
else
{
int i;
for (i=stdopcode_lens_secp[opcode]; i>0; --i)
{
read_pointer ((const uint8_t **) &linep, endunitp, DW_EH_PE_leb128, user, compat_task);
if (linep > endunitp)
return 0;
}
}
// don't worry about doing address advances since we are waiting
// till we hit the end of the sequence or the end of the unit at which
// point the address and linenumber will be reset
if (skip_to_seq_end)
continue;
// calculate actual address advance
if (addr_adv != 0 && opcode != DW_LNS_fixed_advance_pc)
{
addr_adv = min_instr_len * (op_index + addr_adv) / max_ops;
op_index = (op_index + addr_adv) % max_ops;
}
curr_addr += addr_adv;
if (commit_row) {
// compare the whole range from the prior committed row
// (except an end_sequence can't be the base)
if (row_end_sequence == 0 && row_addr <= addr && addr < curr_addr)
{
if (need_filename)
_stp_filename_lookup(m, filename, dirsecp, endhdrp,
row_file_idx, user, compat_task);
return row_linenum;
}
if (end_sequence) {
curr_addr = 0;
curr_file_idx = 1;
curr_linenum = 1;
}
row_addr = curr_addr;
row_file_idx = curr_file_idx;
row_linenum = curr_linenum;
row_end_sequence = end_sequence;
}
}
}
#endif /* STP_NEED_LINE_DATA */
// no linenumber was found otherwise this function would have returned before this point
return 0;
}
static int _stp_build_id_check (struct _stp_module *m,
unsigned long notes_addr,
struct task_struct *tsk)
{
int j;
for (j = 0; j < m->build_id_len; j++) {
/* Use set_fs / get_user to access conceivably invalid addresses.
* If loc2c-runtime.h were more easily usable, a deref() loop
* could do it too. */
mm_segment_t oldfs = get_fs();
int rc;
unsigned char theory, practice = 0;
#ifdef STAPCONF_PROBE_KERNEL
if (!tsk) {
theory = m->build_id_bits[j];
set_fs(KERNEL_DS);
rc = probe_kernel_read(&practice, (void*)(notes_addr + j), 1);
}
else
#endif
{
theory = m->build_id_bits[j];
set_fs (tsk ? USER_DS : KERNEL_DS);
/*
* Why check CONFIG_UTRACE here? If we're using real in-kernel
* utrace, we can always just call get_user() (since we're
* either reading kernel memory or tsk == current).
*
* Since we're only reading here, we can call
* __access_process_vm_noflush(), which only calls things that
* are exported.
*/
#ifdef CONFIG_UTRACE
rc = get_user(practice, ((unsigned char*)(void*)(notes_addr + j)));
#else
if (!tsk || tsk == current) {
rc = get_user(practice, ((unsigned char*)(void*)(notes_addr + j)));
}
else {
rc = (__access_process_vm_noflush(tsk, (notes_addr + j), &practice,
1, 0) != 1);
}
#endif
}
set_fs(oldfs);
if (rc || (theory != practice)) {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
_stp_error ("Build-id mismatch [man error::buildid]: \"%s\" byte %d (0x%02x vs 0x%02x) address %#lx rc %d\n",
m->path, j, theory, practice, notes_addr, rc);
return 1;
#else
/* This branch is a surrogate for kernels affected by Fedora bug
* #465873. */
_stp_warn (KERN_WARNING
"Build-id mismatch [man error::buildid]: \"%s\" byte %d (0x%02x vs 0x%02x) rc %d\n",
m->path, j, theory, practice, rc);
#endif
break;
} /* end mismatch */
} /* end per-byte check loop */
return 0;
}
/* Validate all-modules + kernel based on build-id (if present).
* The completed case is the following combination:
* Debuginfo Module Kernel
* X X
* has build-id/not unloaded has build-id/not
* loaded && (has build-id/not)
*
* NB: build-id exists only if ld>=2.18 and kernel>= 2.6.23
*/
static int _stp_module_check(void)
{
struct _stp_module *m = NULL;
unsigned long notes_addr, base_addr;
unsigned i,j;
int rc = 0;
#ifdef STP_NO_BUILDID_CHECK
return 0;
#endif
for (i = 0; i < _stp_num_modules; i++)
{
m = _stp_modules[i];
if (m->build_id_len > 0 && m->notes_sect != 0) {
dbug_sym(1, "build-id validation [%s]\n", m->name); /* kernel only */
/* skip userspace program */
if (m->name[0] != '/') continue;
/* notes end address */
if (!strcmp(m->name, "kernel")) {
notes_addr = _stp_kmodule_relocate("kernel",
"_stext", m->build_id_offset);
base_addr = _stp_kmodule_relocate("kernel",
"_stext", 0);
} else {
notes_addr = m->notes_sect + m->build_id_offset;
base_addr = m->notes_sect;
}
if (notes_addr <= base_addr) { /* shouldn't happen */
_stp_warn ("build-id address %lx <= base %lx\n",
notes_addr, base_addr);
continue;
}
rc |= _stp_build_id_check (m, notes_addr, NULL);
} /* end checking */
} /* end loop */
return rc;
}
/* Iterate over _stp_modules, looking for a kernel module of given
name. Run build-id checking for it. Return 0 on ok. */
static int _stp_kmodule_check (const char *name)
{
struct _stp_module *m = NULL;
unsigned long notes_addr, base_addr;
unsigned i,j;
#ifdef STP_NO_BUILDID_CHECK
return 0;
#endif
WARN_ON(!name || name[0]=='/'); // non-userspace only
for (i = 0; i < _stp_num_modules; i++)
{
m = _stp_modules[i];
/* PR16406 must be unique kernel module name (non-/-prefixed path) */
if (strcmp (name, m->name)) continue;
if (m->build_id_len > 0 && m->notes_sect != 0) {
dbug_sym(1, "build-id validation [%s]\n", m->name);
/* notes end address */
notes_addr = m->notes_sect + m->build_id_offset;
base_addr = m->notes_sect;
if (notes_addr <= base_addr) { /* shouldn't happen */
_stp_warn ("build-id address %lx < base %lx\n",
notes_addr, base_addr);
continue;
}
return _stp_build_id_check (m, notes_addr, NULL);
} /* end checking */
} /* end loop */
return 0; /* not found */
}
/* Validate user module based on build-id (if present) */
static int _stp_usermodule_check(struct task_struct *tsk, const char *path_name, unsigned long addr)
{
struct _stp_module *m = NULL;
unsigned long notes_addr;
unsigned i, j;
unsigned char practice_id_bits[MAXSTRINGLEN];
unsigned long vm_end = 0;
#ifdef STP_NO_BUILDID_CHECK
return 0;
#endif
WARN_ON(!path_name || path_name[0]!='/'); // user-space only
for (i = 0; i < _stp_num_modules; i++)
{
m = _stp_modules[i];
/* PR16406 must be unique userspace name (/-prefixed path); it's also in m->name */
if (strcmp(path_name, m->path) != 0) continue;
if (m->build_id_len > 0) {
int ret, build_id_len;
notes_addr = addr + m->build_id_offset /* + m->module_base */;
dbug_sym(1, "build-id validation [%d %s] address=%#lx build_id_offset=%#lx\n",
tsk->pid, m->path, addr, m->build_id_offset);
if (notes_addr <= addr) {
_stp_warn ("build-id address %lx < base %lx\n", notes_addr, addr);
continue;
}
return _stp_build_id_check (m, notes_addr, tsk);
}
}
return 0; /* not found */
}
/** Prints an address based on the _STP_SYM flags.
* @param address The address to lookup.
* @param task The address to lookup (if NULL lookup kernel/module address).
* @note Symbolic lookups should not normally be done within
* a probe because it is too time-consuming. Use at module exit time. */
static int _stp_snprint_addr(char *str, size_t len, unsigned long address,
int flags, struct task_struct *task)
{
const char *modname = NULL;
const char *name = NULL;
char *filename = NULL;
unsigned long offset = 0, size = 0, linenumber = 0;
char *exstr, *poststr, *prestr;
prestr = (flags & _STP_SYM_PRE_SPACE) ? " " : "";
exstr = (((flags & _STP_SYM_INEXACT) && (flags & _STP_SYM_SYMBOL))
? " (inexact)" : "");
if (flags & _STP_SYM_POST_SPACE)
poststr = " ";
else if (flags & _STP_SYM_NEWLINE)
poststr = "\n";
else
poststr = "";
if (flags & (_STP_SYM_SYMBOL | _STP_SYM_MODULE)) {
name = _stp_kallsyms_lookup(address, &size, &offset, &modname, task);
if (name && name[0] == '.')
name++;
}
if (modname && (flags & _STP_SYM_MODULE_BASENAME)) {
char *slash = strrchr (modname, '/');
if (slash)
modname = slash+1;
}
if ((flags & _STP_SYM_LINENUMBER) || (flags & _STP_SYM_FILENAME)) {
linenumber = _stp_linenumber_lookup (address, task, &filename,
(int) (flags & _STP_SYM_FILENAME));
}
if (name && (flags & _STP_SYM_SYMBOL)) {
if ((flags & _STP_SYM_MODULE) && modname && *modname) {
if (flags & _STP_SYM_OFFSET) {
if (flags & _STP_SYM_SIZE) {
/* symbol, module, offset and size. */
if (flags & _STP_SYM_HEX_SYMBOL)
return _stp_snprintf(str, len, "%s%p : %s+%#lx/%#lx [%s]%s%s",
prestr, (int64_t) address,
name, offset, size, modname,
exstr, poststr);
else
return _stp_snprintf(str, len, "%s%s+%#lx/%#lx [%s]%s%s",
prestr, name, offset, size,
modname, exstr, poststr);
} else {
/* symbol, module, offset. */
if (flags & _STP_SYM_HEX_SYMBOL)
return _stp_snprintf(str, len, "%s%p : %s+%#lx [%s]%s%s",
prestr, (int64_t) address,
name, offset, modname,
exstr, poststr);
else
return _stp_snprintf(str, len, "%s%s+%#lx [%s]%s%s",
prestr, name, offset,
modname, exstr, poststr);
}
} else {
/* symbol plus module */
if (flags & _STP_SYM_HEX_SYMBOL)
return _stp_snprintf(str, len, "%s%p : %s [%s]%s%s", prestr,
(int64_t) address, name, modname,
exstr, poststr);
else
return _stp_snprintf(str, len, "%s%s [%s]%s%s", prestr, name,
modname, exstr, poststr);
}
} else if (flags & _STP_SYM_OFFSET) {
if (flags & _STP_SYM_SIZE) {
/* symbol name, offset + size, no module name */
if (flags & _STP_SYM_HEX_SYMBOL)
return _stp_snprintf(str, len, "%s%p : %s+%#lx/%#lx%s%s", prestr,
(int64_t) address, name, offset,
size, exstr, poststr);
else
return _stp_snprintf(str, len, "%s%s+%#lx/%#lx%s%s", prestr, name,
offset, size, exstr, poststr);
} else {
/* symbol name, offset, no module name */
if (flags & _STP_SYM_HEX_SYMBOL)
return _stp_snprintf(str, len, "%s%p : %s+%#lx%s%s", prestr,
(int64_t) address, name, offset,
exstr, poststr);
else
return _stp_snprintf(str, len, "%s%s+%#lx%s%s", prestr, name,
offset, exstr, poststr);
}
} else {
/* symbol name only */
if (flags & _STP_SYM_HEX_SYMBOL)
return _stp_snprintf(str, len, "%s%p : %s%s%s", prestr,
(int64_t) address, name, exstr, poststr);
else
return _stp_snprintf(str, len, "%s%s%s%s", prestr, name,
exstr, poststr);
}
} else {
/* no symbol name */
if (modname && *modname && (flags & _STP_SYM_MODULE)) {
if (flags & _STP_SYM_OFFSET) {
if (flags & _STP_SYM_SIZE) {
/* hex address, module name, offset + size */
return _stp_snprintf(str, len, "%s%p [%s+%#lx/%#lx]%s%s", prestr,
(int64_t) address, modname, offset,
size, exstr, poststr);
} else {
/* hex address, module name, offset */
return _stp_snprintf(str, len, "%s%p [%s+%#lx]%s%s", prestr,
(int64_t) address, modname, offset,
exstr, poststr);
}
} else {
/* hex address, module name */
return _stp_snprintf(str, len, "%s%p [%s]%s%s", prestr,
(int64_t) address, modname, exstr, poststr);
}
#ifdef STAPCONF_MODULE_TEXT_ADDRESS
} if ((flags & _STP_SYM_MODULE) && ! task) {
/* No symbol, nor module name, but user really wants one, do one
last try. */
struct module *ko;
preempt_disable();
ko = __module_text_address (address);
if (ko && ko->name)
{
/* hex address, module name */
int ret = _stp_snprintf(str, len, "%s%p [%s]%s%s", prestr,
(int64_t) address, ko->name, exstr, poststr);
preempt_enable_no_resched();
return ret;
}
preempt_enable_no_resched();
/* no names, hex only */
return _stp_snprintf(str, len, "%s%p%s%s", prestr,
(int64_t) address, exstr, poststr);
#endif
} else if ((flags & _STP_SYM_LINENUMBER) && linenumber) {
if (flags & _STP_SYM_FILENAME) {
if (filename) {
/* filename, linenumber */
return _stp_snprintf(str, len, "%s%s:%#lu%s%s", prestr,
filename, linenumber, exstr, poststr);
} else {
/* filename=??, linenumber */
return _stp_snprintf(str, len, "%s??:%#lu%s%s", prestr,
linenumber, exstr, poststr);
}
} else {
/* linenumber */
return _stp_snprintf(str, len, "%s%#lu%s%s", prestr,
linenumber, exstr, poststr);
}
} else if ((flags & _STP_SYM_FILENAME) && filename) {
/* filename */
return _stp_snprintf(str, len, "%s%s%s%s", prestr,
filename, exstr, poststr);
}else {
/* no names, hex only */
return _stp_snprintf(str, len, "%s%p%s%s", prestr,
(int64_t) address, exstr, poststr);
}
}
}
static void _stp_print_addr(unsigned long address, int flags,
struct task_struct *task)
{
_stp_snprint_addr(NULL, 0, address, flags, task);
}
/** @} */
/* Update the given module/section's offset value. Assume that there
is no need for locking or for super performance. NB: this is only
for kernel modules, which exist singly at run time. User-space
modules (executables, shared libraries) exist at different
addresses in different processes, so are tracked in the
_stp_tf_vma_map. */
static void _stp_kmodule_update_address(const char* module,
const char* reloc, /* NULL="all" */
unsigned long address)
{
unsigned mi, si;
for (mi=0; mi<_stp_num_modules; mi++)
{
const char *note_sectname = ".note.gnu.build-id";
if (strcmp (_stp_modules[mi]->name, module))
continue;
if (!reloc || !strcmp (note_sectname, reloc)) {
dbug_sym(1, "module %s special section %s address %#lx\n",
_stp_modules[mi]->name,
note_sectname,
address);
_stp_modules[mi]->notes_sect = address; /* cache this particular address */
}
for (si=0; si<_stp_modules[mi]->num_sections; si++)
{
if (reloc && strcmp (_stp_modules[mi]->sections[si].name, reloc))
continue;
else
{
dbug_sym(1, "module %s section %s address %#lx\n",
_stp_modules[mi]->name,
_stp_modules[mi]->sections[si].name,
address);
_stp_modules[mi]->sections[si].static_addr = address;
if (reloc) break;
else continue; /* wildcarded - will have more hits */
}
} /* loop over sections */
} /* loop over modules */
}
#ifndef STAPCONF_KALLSYMS
unsigned long kallsyms_lookup_name (const char *name)
{
/* NB: PR14804: don't use _stp_error here. It's called too
early for the actual message buffer goo to be allocated. */
/* Don't even printk. A user can't do anything about it. */
/* printk (KERN_ERR "kallsyms_lookup_name unavailable for %s\n", name); */
return 0;
}
#endif
#endif /* _STP_SYM_C_ */