/usr/share/systemtap/tapset
Edit: /usr/share/systemtap/tapset/context.stp (6103B)
// context tapset
// Copyright (C) 2005-2011 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.
//
// Context functions provide additional information about where an event occurred. These functions can
//provide information such as a backtrace to where the event occurred and the current register values for the
//processor.
//
/**
* sfunction print_regs - Print a register dump
*
* Description: This function prints a register dump. Does nothing if no registers are available for the probe point.
*/
function print_regs ()
%{
if (c->user_mode_p && CONTEXT->uregs) {
_stp_print_regs (CONTEXT->uregs);
} else if (CONTEXT->kregs) {
_stp_print_regs (CONTEXT->kregs);
}
%}
function umodbuildid:string (address:long)
%{ /* pragma:vma */
void *ubid_struct = NULL;
int i,j;
struct _stp_module * p;
static const char hex[] = "0123456789abcdef";
stap_find_vma_map_info(current, STAP_ARG_address,
NULL, NULL, NULL, NULL, &ubid_struct);
p = (struct _stp_module*) ubid_struct;
if (p == NULL){
STAP_ERROR("umodbuildid 0x%llx unknown\n ", STAP_ARG_address);
}
for(i=0,j=0; j < p->build_id_len; ++j && i < MAXSTRINGLEN)
{
unsigned char temp = p->build_id_bits[j];
STAP_RETVALUE[i++] = hex[temp >> 4];
STAP_RETVALUE[i++] = hex[temp & 15];
}
%}
# Finds the module-relative offset of the given address in the current user process
function umodaddr:long (address:long)
%{ /* pragma:vma */
long vm_start = -1;
stap_find_vma_map_info(current, STAP_ARG_address,
&vm_start, NULL, NULL, NULL,NULL);
if(vm_start == -1)
STAP_ERROR("umodaddr 0x%llx unknown\n ", STAP_ARG_address);
STAP_RETURN(STAP_ARG_address - vm_start);
%}
/**
* sfunction pp - Returns the active probe point
*
* Description: This function returns the fully-resolved probe point
* associated with a currently running probe handler, including alias
* and wild-card expansion effects. Context: The current probe point.
*/
function pp:string ()
%{ /* pure */ /* unprivileged */ /* stable */
strlcpy (STAP_RETVALUE, CONTEXT->probe_point, MAXSTRINGLEN);
%}
/**
* sfunction ppfunc - Returns the function name parsed from pp()
*
* Description: This returns the function name from the current pp().
* Not all pp() have functions in them, in which case "" is returned.
*/
function ppfunc:string ()
%{ /* pure */ /* unprivileged */ /* stable */
char *ptr, *start;
/* This is based on the pre-2.0 behavior of probefunc(), but without
* the _stp_snprint_addr fallback, so we're purely pp()-based.
*
* The obsolete inline("...") syntax is dropped, but in its place we'll
* look for function names in statement("...") form.
*/
STAP_RETVALUE[0] = '\0';
start = strstr(CONTEXT->probe_point, "function(\"");
ptr = start + 10;
if (!start) {
start = strstr(CONTEXT->probe_point, "statement(\"");
ptr = start + 11;
}
if (start) {
int len = MAXSTRINGLEN;
char *dst = STAP_RETVALUE;
while (*ptr != '@' && *ptr != '"' && --len > 0 && *ptr)
*dst++ = *ptr++;
*dst = 0;
}
%}
/**
* sfunction probe_type - The low level probe handler type of the current probe.
*
* Description: Returns a short string describing the low level probe handler
* type for the current probe point. This is for informational purposes only.
* Depending on the low level probe handler different context functions can
* or cannot provide information about the current event (for example some
* probe handlers only trigger in user space and have no associated kernel
* context). High-level probes might map to the same or different low-level
* probes (depending on systemtap version and/or kernel used).
*/
function probe_type:string()
%{ /* pure */ /* unprivileged */ /* stable */
switch (CONTEXT->probe_type)
{
case stp_probe_type_been:
strlcpy (STAP_RETVALUE, "begin_end", MAXSTRINGLEN);
break;
case stp_probe_type_itrace:
strlcpy (STAP_RETVALUE, "itrace", MAXSTRINGLEN);
break;
case stp_probe_type_marker:
strlcpy (STAP_RETVALUE, "kernel_marker", MAXSTRINGLEN);
break;
case stp_probe_type_perf:
strlcpy (STAP_RETVALUE, "perf_event", MAXSTRINGLEN);
break;
case stp_probe_type_procfs:
strlcpy (STAP_RETVALUE, "procfs", MAXSTRINGLEN);
break;
case stp_probe_type_timer:
strlcpy (STAP_RETVALUE, "timer", MAXSTRINGLEN);
break;
case stp_probe_type_hrtimer:
strlcpy (STAP_RETVALUE, "hrtimer", MAXSTRINGLEN);
break;
case stp_probe_type_profile_timer:
strlcpy (STAP_RETVALUE, "profile_timer", MAXSTRINGLEN);
break;
case stp_probe_type_netfilter:
strlcpy (STAP_RETVALUE, "netfilter", MAXSTRINGLEN);
break;
case stp_probe_type_utrace:
strlcpy (STAP_RETVALUE, "utrace", MAXSTRINGLEN);
break;
case stp_probe_type_utrace_syscall:
strlcpy (STAP_RETVALUE, "utrace_syscall", MAXSTRINGLEN);
break;
case stp_probe_type_kprobe:
strlcpy (STAP_RETVALUE, "kprobe", MAXSTRINGLEN);
break;
case stp_probe_type_kretprobe:
strlcpy (STAP_RETVALUE, "kretprobe", MAXSTRINGLEN);
break;
case stp_probe_type_uprobe:
strlcpy (STAP_RETVALUE, "uprobe", MAXSTRINGLEN);
break;
case stp_probe_type_uretprobe:
strlcpy (STAP_RETVALUE, "uretprobe", MAXSTRINGLEN);
break;
case stp_probe_type_hwbkpt:
strlcpy (STAP_RETVALUE, "hardware_data_breakpoint", MAXSTRINGLEN);
break;
case stp_probe_type_tracepoint:
strlcpy (STAP_RETVALUE, "kernel_tracepoint", MAXSTRINGLEN);
break;
default:
/* This should never happen. */
snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer),
"Unknown probe-type state %d", CONTEXT->probe_type);
CONTEXT->last_error = CONTEXT->error_buffer;
break;
}
%}