diff options
Diffstat (limited to 'gdb/testsuite/lib/pdtrace.in')
| -rwxr-xr-x | gdb/testsuite/lib/pdtrace.in | 1033 |
1 files changed, 1033 insertions, 0 deletions
diff --git a/gdb/testsuite/lib/pdtrace.in b/gdb/testsuite/lib/pdtrace.in new file mode 100755 index 0000000..118b017 --- /dev/null +++ b/gdb/testsuite/lib/pdtrace.in @@ -0,0 +1,1033 @@ +#!/bin/sh + +# A Poor(but Free)'s Man dtrace +# +# Copyright (C) 2014, 2015 Free Software Foundation, Inc. +# +# Contributed by Oracle, Inc. +# +# This file is part of GDB. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see +# <http://www.gnu.org/licenses/>. + +# DISCLAIMER DISCLAIMER DISCLAIMER +# This script is a test tool. As such it is in no way intended to +# replace the "real" dtrace command for any practical purpose, apart +# from testing the DTrace USDT probes support in GDB. + +# that said... +# +# pdtrace is a limited dtrace program, implementing a subset of its +# functionality: +# +# - The generation of an ELF file containing an embedded dtrace +# program. Equivalent to dtrace -G. +# +# - The generation of a header file with definitions for static +# probes. Equivalent to dtrace -h. +# +# This allows to generate DTrace static probes without having to use +# the user-level DTrace components. The generated objects are 100% +# compatible with DTrace and can be traced by the dtrace kernel module +# like if they were generated by dtrace. +# +# Some of the known limitations of this implementation are: +# - The input d-script must describe one provider, and only one. +# - The "probe " directives in the d-file must not include argument +# names, just the types. Thus something like `char *' is valid, but +# `char *name' is not. +# - The command line options must precede other arguments, since the +# script uses the (more) portable getopts. +# - Each probe header in the d-script must be contained in +# a single line. +# - strip -K removes the debugging information from the input object +# file. +# - The supported target platforms are i[3456]86 and x86_64. +# +# Please keep this code as portable as possible. Restrict yourself to +# POSIX sh. + +# This script uses the following external programs, defined in +# variables. Some of them are substituted by autoconf. + +TR=tr +NM=@NM_TRANSFORM_NAME@ +EGREP=egrep +SED=sed +CUT=cut +READELF=@READELF_TRANSFORM_NAME@ +SORT=sort +EXPR=expr +WC=wc +UNIQ=uniq +HEAD=head +SEQ=seq +AS=@GAS_TRANSFORM_NAME@ +STRIP=@STRIP_TRANSFORM_NAME@ +TRUE=true + +# Sizes for several DOF structures, in bytes. +# +# See linux/dtrace/dof.h for the definition of the referred +# structures. + +dof_hdrsize=64 # sizeof(dtrace_dof_hdr) +dof_secsize=32 # sizeof(dtrace_dof_sect) +dof_probesize=48 # sizeof(dtrace_dof_probe) +dof_providersize=44 # sizeof(dtrace_dof_provider) + +# Types for the several DOF sections. +# +# See linux/dtrace/dof_defines.h for a complete list of section types +# along with their values. + +dof_sect_type_strtab=8 +dof_sect_type_provider=15 +dof_sect_type_probes=16 +dof_sect_type_prargs=17 +dof_sect_type_proffs=18 +dof_sect_type_prenoffs=26 + +### Functions + +# Write a message to the standard error output and exit with an error +# status. +# +# Arguments: +# $1 error message. + +f_panic() +{ + echo "error: $1" 1>&2; exit 1 +} + +# Write a usage message to the standard output and exit with an error +# status. + +f_usage() +{ + printf "Usage: pdtrace [-32|-64] [-GhV] [-o output] [-s script] [ args ... ]\n\n" + + printf "\t-32 generate 32-bit ELF files\n" + printf "\t-64 generate 64-bit ELF files\n\n" + + printf "\t-G generate an ELF file containing embedded dtrace program\n" + printf "\t-h generate a header file with definitions for static probes\n" + printf "\t-o set output file\n" + printf "\t-s handle probes according to the specified D script\n" + printf "\t-V report the DTrace API version implemented by the tool\n" + exit 2 +} + +# Write a version message to the standard output and exit with a +# successful status. + +f_version() +{ + echo "pdtrace: Sun D 1.6.3" + exit +} + +# Add a new record to a list and return it. +# +# Arguments: +# $1 is the list. +# $2 is the new record + +f_add_record() +{ + rec=$1 + test -n "$rec" && \ + { rec=$(printf %s\\n "$rec"; echo x); rec=${rec%x}; } + printf %s "$rec$2" +} + +# Collect the providers and probes information from the input object +# file. +# +# This function sets the values of the following global variables. +# The values are structured in records, each record in a line. The +# fields of each record are separated in some cases by white +# characters and in other cases by colon (:) characters. +# +# The type codes in the line format descriptors are: +# S: string, D: decimal number +# +# probes +# Regular probes and is-enabled probes. +# TYPE(S) PROVIDER(S) NAME(S) OFFSET(D) BASE(D) BASE_SYM(S) +# base_probes +# Base probes, i.e. probes sharing provider, name and container. +# PROVIDER(S) NAME(S) BASE(D) BASE_SYM(S) +# providers +# List of providers. +# PROVIDER(S) +# All the offsets are expressed in bytes. +# +# Input globals: +# objfile +# Output globals: +# probes, base_probes, providers + +probes= +base_probes= +providers= +probes_args= + +f_collect_probes() +{ + # Probe points are function calls to undefined functions featuring + # distinct names for both normal probes and is-enabled probes. + PROBE_REGEX="(__dtrace_([a-zA-Z_]+)___([a-zA-Z_]+))" + EPROBE_REGEX="(__dtraceenabled_([a-zA-Z_]+)___([a-zA-Z_]+))" + + while read type symbol provider name; do + test -z "$type" && f_panic "No probe points found in $objfile" + + provider=$(printf %s $provider | $TR -s _) + name=$(printf %s $name | $TR -s _) + + # Search the object file for relocations defined for the + # probe symbols. Then calculate the base address of the + # probe (along with the symbol associated with that base + # address) and the offset of the probe point. + for offset in $($READELF -W -r $objfile | $EGREP $symbol | $CUT -d' ' -f1) + do + # Figure out the base address for the probe. This is + # done finding the function name in the text section of + # the object file located above the probed point. But + # note that the relocation is for the address operand of + # the call instruction, so we have to subtract 1 to find + # the real probed point. + offset=$((0x$offset - 1)) + + # The addresses of is-enabled probes must point to the + # first NOP instruction in their patched instructions + # sequences, so modify them (see f_patch_objfile for the + # instruction sequences). + if test "$type" = "e"; then + if test "$objbits" -eq "32"; then + offset=$((offset + 2)) + else # 64 bits + offset=$((offset + 3)) + fi + fi + + # Determine the base address of the probe and its + # corresponding function name. + funcs=$($NM -td $objfile | $EGREP "^[0-9]+ T " \ + | $CUT -d' ' -f1,3 | $SORT -n -r | $TR ' ' :) + for fun in $funcs; do + func_off=$(printf %s $fun | $CUT -d: -f1) + func_sym=$(printf %s $fun | $CUT -d: -f2) + # Note that `expr' is used to remove leading zeros + # to avoid FUNC_OFF to be interpreted as an octal + # number in arithmetic contexts. + test "$func_off" -le "$offset" && \ + { base=$($EXPR $func_off + 0); break; } + done + test -n "$base" || \ + f_panic "could not find base address for probe at $objfile($o)" + + # Emit the record for the probe. + probes=$(f_add_record "$probes" \ + "$type $provider $name $(($offset - $base)) $base $func_sym") + done + done <<EOF +$($NM $objfile | $EGREP " U $PROBE_REGEX" \ + | $SED -E -e "s/.*$PROBE_REGEX.*/p \1 \2 \3/"; + $NM $objfile | $EGREP " U $EPROBE_REGEX" \ + | $SED -E -e "s/.*$EPROBE_REGEX.*/e \1 \2 \3/") +EOF + + # Build the list of providers and of base probes from the probes. + while read type provider name offset base base_sym; do + providers=$(f_add_record "$providers" "$provider") + base_probes=$(f_add_record "$base_probes" "$provider $name $base $base_sym") + done <<EOF +$probes +EOF + providers=$(printf %s\\n "$providers" | $SORT | $UNIQ) + base_probes=$(printf %s\\n "$base_probes" | $SORT | $UNIQ) +} + +# Collect the argument counts and type strings for all the probes +# described in the `probes' global variable. This is done by +# inspecting the d-script file provided by the user. +# +# This function sets the values of the following global variables. +# The values are structured in records, each record in a line. The +# fields of each record are separated in some cases by white +# characters and in other cases by colon (:) characters. +# +# The type codes in the line format descriptors are: +# S: string, D: decimal number +# +# probes_args +# Probes arguments. +# PROVIDER(S):NAME(S):NARGS(D):ARG1(S):ARG2(S):...:ARGn(S) +# +# Input globals: +# probes +# Output globals: +# probes_args +# Arguments: +# $1 is the d-script file from which to extract the arguments +# information. + +f_collect_probes_args() +{ + dscript=$1 + while read type provider name offset base base_sym; do + # Process normal probes only. Is-enabled probes are not + # described in the d-script file and they don't receive any + # argument. + test "$type" = "p" || continue + + # Names are mangled in d-script files to make it possible to + # have underscore characters as part of the provider name and + # probe name. + m_provider=$(printf %s $provider | $SED -e 's/_/__/g') + m_name=$(printf %s $name | $SED -e 's/_/__/g') + + # Ignore this probe if the d-script file does not describe its + # provider. + $EGREP -q "provider +$m_provider" $dscript || continue + + # Look for the line containing the description of the probe. + # If we can't find it then ignore this probe. + line=$($EGREP "^ *probe +$m_name *\(.*\);" $dscript) + test -n "$line" || continue + + # Ok, extract the argument types from the probe prototype. + # This is fragile as hell as it requires the prototype to be + # in a single line. + args=""; nargs=0; line=$(printf %s "$line" | $SED -e 's/.*(\(.*\)).*/\1/') + set -f; IFS=, + for arg in $line; do + args="$args:$arg" + nargs=$((nargs + 1)) + done + set +f; unset IFS + + # Emit the record for the probe arguments. + probes_args=$(f_add_record "$probes_args" "$provider:$name:$nargs$args") + done <<EOF +$probes +EOF +} + +# Functions to manipulate the global BCOUNT. + +BCOUNT=0 + +f_incr_bcount() +{ + BCOUNT=$((BCOUNT + $1)) +} + +f_align_bcount() +{ + test $((BCOUNT % $1)) -eq 0 || BCOUNT=$((BCOUNT + ($1 - (BCOUNT % $1)))) +} + +# Generate a line of assembly code and add it to the asmprogram global +# variable. +# +# Arguments: +# $1 string to generate in a line. + +asmprogram= + +f_gen_asm() +{ + line=$(printf "\t$1") + asmprogram=$(f_add_record "$asmprogram" "$line") +} + +# Helper function to generate the assembly code of a DOF section +# header. +# +# This function is used by `f_gen_dof_program'. +# +# Arguments: +# $1 is the name of the described section. +# $2 is the type of the described section. +# $3 is the alignment of the described section. +# $4 is the number of entities stored in the described section. +# $5 is the offset in the DOF program of the described section. +# $6 is the size of the described section, in bytes. + +f_gen_dof_sect_header() +{ + f_gen_asm "" + f_gen_asm "/* dtrace_dof_sect for the $1 section. */" + f_gen_asm ".balign 8" + f_gen_asm ".4byte $2\t/* uint32_t dofs_type */" + f_gen_asm ".4byte $3\t/* uint32_t dofs_align */" + # The DOF_SECF_LOAD flag is 1 => loadable section. + f_gen_asm ".4byte 1\t/* uint32_t dofs_flags */" + f_gen_asm ".4byte $4\t/* uint32_t dofs_entsize */" + f_gen_asm ".8byte $5\t/* uint64_t dofs_offset */" + f_gen_asm ".8byte $6\t/* uint64_t dofs_size */" +} + +# Generate a DOF program and assembly it in the output file. +# +# The DOF program generated by this function has the following +# structure: +# +# HEADER +# STRTAB OFFTAB EOFFTAB [PROBES PROVIDER]... +# STRTAB_SECT OFFTAB_SECT EOFFTAB_SECT ARGTAB_SECT [PROBES_SECT PROVIDER_SECT]... +# +# Input globals: +# probes, base_probes, providers, probes_args, BCOUNT + +f_gen_dof_program() +{ + ###### Variables used to cache information needed later. + + # Number of section headers in the generated DOF program. + dof_secnum=0 + # Offset of section headers in the generated DOF program, in bytes. + dof_secoff=0 + + # Sizes of the STRTAB, OFFTAB and EOFFTAB sections, in bytes. + strtab_size=0 + offtab_size=0 + eofftab_size=0 + + # Offsets of the STRTAB, OFFTAB EOFFTAB and PROBES sections in the + # generated DOF program. In bytes. + strtab_offset=0 + offtab_offset=0 + eofftab_offset=0 + argtab_offset=0 + probes_offset=0 + + # Indexes of the section headers of the STRTAB, OFFTAB, EOFFTAB and + # PROBES sections in the sections array. + strtab_sect_index=0 + offtab_sect_index=0 + eofftab_sect_index=0 + argtab_sect_index=0 + probes_sect_index=0 + + # First offsets and eoffsets of the base-probes. + # Lines: PROVIDER(S) NAME(S) BASE(D) (DOF_OFFSET(D)|DOF_EOFFSET(D)) + probes_dof_offsets= + probes_dof_eoffsets= + + # Offsets in the STRTAB section for the first type of base probes. + # Record per line: PROVIDER(S) NAME(S) BASE(D) OFFSET(D) + probes_dof_types= + + + # Offsets of the provider names in the provider's STRTAB section. + # Lines: PROVIDER(S) OFFSET(D) + providers_dof_names= + + # Offsets of the base-probe names in the provider's STRTAB section. + # Lines: PROVIDER(S) NAME(S) BASE(D) OFFSET(D) + probes_dof_names= + + # Offsets of the provider sections in the DOF program. + # Lines: PROVIDER(S) OFFSET(D) + providers_offsets= + + ###### Generation phase. + + # The header of the DOF program contains a `struct + # dtrace_dof_hdr'. Record its size, but it is written at the end + # of the function. + f_incr_bcount $dof_hdrsize; f_align_bcount 8 + + # The STRTAB section immediately follows the header. It contains + # the following set of packed null-terminated strings: + # + # [PROVIDER [BASE_PROBE_NAME [BASE_PROBE_ARG_TYPE...]]...]... + strtab_offset=$BCOUNT + strtab_sect_index=$dof_secnum + dof_secnum=$((dof_secnum + 1)) + f_gen_asm "" + f_gen_asm "/* The STRTAB section. */" + f_gen_asm ".balign 8" + # Add the provider names. + off=0 + while read provider; do + strtab_size=$(($strtab_size + ${#prov} + 1)) + # Note the funny mangling... + f_gen_asm ".asciz \"$(printf %s $provider | $TR _ -)\"" + providers_dof_names=$(f_add_record "$providers_dof_names" \ + "$provider $off") + off=$(($off + ${#provider} + 1)) + + # Add the base-probe names. + while read p_provider name base base_sym; do + test "$p_provider" = "$provider" || continue + # And yes, more funny mangling... + f_gen_asm ".asciz \"$(printf %s $name | $TR _ -)\"" + probes_dof_names=$(f_add_record "$probes_dof_names" \ + "$p_provider $name $base $off") + off=$(($off + ${#name} + 1)) + while read args; do + a_provider=$(printf %s "$args" | $CUT -d: -f1) + a_name=$(printf %s "$args" | $CUT -d: -f2) + test "$a_provider" = "$p_provider" \ + && test "$a_name" = "$name" \ + || continue + + probes_dof_types=$(f_add_record "$probes_dof_types" \ + "$a_provider $name $base $off") + nargs=$(printf %s "$args" | $CUT -d: -f3) + for n in $($SEQ $nargs); do + arg=$(printf %s "$args" | $CUT -d: -f$(($n + 3))) + f_gen_asm ".asciz \"${arg}\"" + off=$(($off + ${#arg} + 1)) + done + done <<EOF +$probes_args +EOF + done <<EOF +$base_probes +EOF + done <<EOF +$providers +EOF + strtab_size=$off + f_incr_bcount $strtab_size; f_align_bcount 8 + + # The OFFTAB section contains a set of 32bit words, one per + # defined regular probe. + offtab_offset=$BCOUNT + offtab_sect_index=$dof_secnum + dof_secnum=$((dof_secnum + 1)) + f_gen_asm "" + f_gen_asm "/* The OFFTAB section. */" + f_gen_asm ".balign 8" + off=0 + while read type provider name offset base base_sym; do + test "$type" = "p" || continue + f_gen_asm ".4byte $offset\t/* probe ${provider}:${name} */" + probes_dof_offsets=$(f_add_record "$probes_dof_offsets" \ + "$provider $name $base $off") + off=$(($off + 4)) + done <<EOF +$probes +EOF + offtab_size=$off + f_incr_bcount $offtab_size; f_align_bcount 8 + + # The EOFFTAB section contains a set of 32bit words, one per + # defined is-enabled probe. + eofftab_offset=$BCOUNT + eofftab_sect_index=$dof_secnum + dof_secnum=$((dof_secnum + 1)) + f_gen_asm "" + f_gen_asm "/* The EOFFTAB section. */" + f_gen_asm ".balign 8" + off=0 + while read type provider name offset base base_sym; do + test "$type" = "e" || continue + f_gen_asm ".4byte $offset\t/* is-enabled probe ${provider}:${name} */" + probes_dof_eoffsets=$(f_add_record "$probes_dof_eoffsets" \ + "$provider $name $base $off") + off=$(($off + 4)) + done <<EOF +$probes +EOF + eofftab_size=$off + f_incr_bcount $eofftab_size; f_align_bcount 8 + + # The ARGTAB section is empty, but nonetheless has a section + # header, so record its section index here. + argtab_offset=0 + argtab_sect_index=$dof_secnum + dof_secnum=$((dof_secnum + 1)) + + # Generate a pair of sections PROBES and PROVIDER for each + # provider. + while read prov; do + # The PROBES section contains an array of `struct + # dtrace_dof_probe'. + # + # A `dtrace_dof_probe' entry characterizes the collection of + # probes and is-enabled probes sharing the same provider, name and + # base address. + probes_sect_index=$dof_secnum + dof_secnum=$((dof_secnum + 1)) + probes_offset=$BCOUNT + num_base_probes=$(printf %s\\n "$base_probes" | $WC -l) + while read provider name base base_sym; do + name_offset=$(printf %s\\n "$probes_dof_names" \ + | $EGREP "^$provider $name " | $CUT -d' ' -f4) + + num_offsets=$(printf %s\\n "$probes_dof_offsets" \ + | $EGREP "^$provider $name [0-9]+ " | $WC -l) + + first_offset=0 + test "$num_offsets" -gt 0 && \ + first_offset=$(printf %s\\n "$probes_dof_offsets" \ + | $EGREP "^$provider $name " | $CUT -d' ' -f4 | $HEAD -1) + + num_eoffsets=$(printf %s\\n "$probes_dof_eoffsets" \ + | $EGREP "^$provider $name [0-9]+ " | $WC -l) + first_eoffset=0 + test "$num_eoffsets" -gt 0 && \ + first_eoffset=$(printf %s "$probes_dof_eoffsets" \ + | $EGREP "^$provider $name " | $CUT -d' ' -f4 | $HEAD -1) + + num_args=$(printf %s "$probes_args" \ + | $EGREP "^$provider:$name:" | $CUT -d: -f3 | $HEAD -1) + + first_type=$(printf %s "$probes_dof_types" \ + | $EGREP "^$provider $name $base " | $CUT -d' ' -f4 | $HEAD -1) + + reloctype=R_X86_64_GLOB_DAT + test "$objbits" = "32" && reloctype=R_386_32 + + f_gen_asm "" + f_gen_asm "/* dtrace_dof_probe for ${provider}:${name} at ${base_sym} */" + f_gen_asm ".balign 8" + f_gen_asm ".reloc ., $reloctype, $base_sym + 0" + f_gen_asm ".8byte ${base}\t/* uint64_t dofpr_addr */" + f_gen_asm ".4byte 0\t/* uint32_t dofpr_func */" + f_gen_asm ".4byte $name_offset\t/* uint32_t dofpr_name */" + f_gen_asm ".4byte $first_type\t/* uint32_t dofpr_nargv */" + f_gen_asm ".4byte 0\t/* uint32_t dofpr_xargv */" + f_gen_asm ".4byte 0\t/* uint32_t dofpr_argidx */" + f_gen_asm ".4byte $(($first_offset/4))\t/* uint32_t dofpr_offidx */" + f_gen_asm ".byte $num_args\t/* uint8_t dofpr_nargc */" + f_gen_asm ".byte 0\t/* uint8_t dofpr_xargc */" + f_gen_asm ".2byte $num_offsets\t/* uint16_t dofpr_noffs */" + f_gen_asm ".4byte $(($first_eoffset/4))\t/* uint32_t dofpr_enoffidx */" + f_gen_asm ".2byte $num_eoffsets\t/* uint16_t dofpr_nenoffs */" + f_gen_asm ".2byte 0\t/* uint16_t dofpr_pad1 */" + f_gen_asm ".4byte 0\t/* uint16_t dofpr_pad2 */" + + f_incr_bcount "$dof_probesize" + done <<EOF +$base_probes +EOF + + # The PROVIDER section contains a `struct dtrace_dof_provider' + # instance describing the provider for the probes above. + dof_secnum=$((dof_secnum + 1)) + providers_offsets=$(f_add_record "$providers_offsets" \ + "$prov $BCOUNT") + # The dtrace_dof_provider. + provider_name_offset=$(printf %s "$providers_dof_names" \ + | $EGREP "^$prov " | $CUT -d' ' -f2) + + f_gen_asm "" + f_gen_asm "/* dtrace_dof_provider for $prov */" + f_gen_asm ".balign 8" + # Links to several DOF sections. + f_gen_asm ".4byte $strtab_sect_index\t/* uint32_t dofpv_strtab */" + f_gen_asm ".4byte $probes_sect_index\t/* uint32_t dofpv_probes */" + f_gen_asm ".4byte $argtab_sect_index\t/* uint32_t dofpv_prargs */" + f_gen_asm ".4byte $offtab_sect_index\t/* uint32_t dofpv_proffs */" + # Offset of the provider name into the STRTAB section. + f_gen_asm ".4byte $provider_name_offset\t/* uint32_t dofpv_name */" + # The rest of fields can be 0 for our modest purposes :) + f_gen_asm ".4byte 0\t/* uint32_t dofpv_provattr */" + f_gen_asm ".4byte 0\t/* uint32_t dofpv_modattr */" + f_gen_asm ".4byte 0\t/* uint32_t dofpv_funcattr */" + f_gen_asm ".4byte 0\t/* uint32_t dofpv_nameattr */" + f_gen_asm ".4byte 0\t/* uint32_t dofpv_argsattr */" + # But not this one, of course... + f_gen_asm ".4byte $eofftab_sect_index\t/* uint32_t dofpv_prenoffs */" + + f_incr_bcount $dof_providersize + done<<EOF +$providers +EOF + f_align_bcount 8 + + # The section headers follow, one per section defined above. + dof_secoff=$BCOUNT + + f_gen_dof_sect_header STRTAB \ + $dof_sect_type_strtab \ + 1 1 $strtab_offset $strtab_size + f_incr_bcount $dof_secsize; f_align_bcount 8 + + f_gen_dof_sect_header OFFTAB \ + $dof_sect_type_proffs \ + 4 4 $offtab_offset $offtab_size + f_incr_bcount $dof_secsize; f_align_bcount 8 + + f_gen_dof_sect_header EOFFTAB \ + $dof_sect_type_prenoffs \ + 4 4 $eofftab_offset $eofftab_size + f_incr_bcount $dof_secsize; f_align_bcount 8 + + f_gen_dof_sect_header ARGTAB \ + $dof_sect_type_prargs \ + 4 1 $argtab_offset 0 + f_incr_bcount $dof_secsize; f_align_bcount 8 + + while read provider; do + provider_offset=$(printf %s "$providers_offsets" \ + | $EGREP "^$provider " | $CUT -d' ' -f2) + num_base_probes=$(printf %s\\n "$base_probes" | $WC -l) + + f_gen_dof_sect_header "$provider probes" \ + $dof_sect_type_probes \ + 8 $dof_probesize $probes_offset \ + $((num_base_probes * dof_probesize)) + f_incr_bcount $dof_secsize; f_align_bcount 8 + + f_gen_dof_sect_header "$provider provider" \ + $dof_sect_type_provider \ + 8 1 $provider_offset $dof_providersize + f_incr_bcount $dof_secsize; f_align_bcount 8 + done <<EOF +$providers +EOF + + # Finally, cook the header. + asmbody="$asmprogram" + asmprogram="" + f_gen_asm "/* File generated by pdtrace. */" + f_gen_asm "" + + f_gen_asm ".section .SUNW_dof,\"a\",\"progbits\"" + f_gen_asm ".globl __SUNW_dof" + f_gen_asm ".hidden __SUNW_dof" + f_gen_asm ".size __SUNW_dof, ${BCOUNT}" + f_gen_asm ".type __SUNW_dof, @object" + f_gen_asm "__SUNW_dof:" + + f_gen_asm "" + f_gen_asm "/* dtrace_dof_hdr */" + f_gen_asm ".balign 8" + f_gen_asm ".byte 0x7f, 'D, 'O, 'F\t/* dofh_ident[0..3] */" + f_gen_asm ".byte 2\t\t/* model: 1=ILP32, 2=LP64 */" + f_gen_asm ".byte 1\t\t/* encoding: 1: little-endian, 2: big-endian */" + f_gen_asm ".byte 2\t\t/* DOF version: 1 or 2. Latest is 2 */" + f_gen_asm ".byte 2\t\t/* DIF version: 1 or 2. Latest is 2 */" + f_gen_asm ".byte 8\t\t/* number of DIF integer registers */" + f_gen_asm ".byte 8\t\t/* number of DIF tuple registers */" + f_gen_asm ".byte 0, 0\t\t/* dofh_ident[10..11] */" + f_gen_asm ".4byte 0\t\t/* dofh_ident[12..15] */" + f_gen_asm ".4byte 0\t/* uint32_t dofh_flags */" # See Limitations above. + f_gen_asm ".4byte ${dof_hdrsize}\t/* uint32_t dofh_hdrsize */" + f_gen_asm ".4byte ${dof_secsize}\t/* uint32_t dofh_secsize */" + f_gen_asm ".4byte ${dof_secnum}\t/* uint32_t dofh_secnum */" + f_gen_asm ".8byte ${dof_secoff}\t/* uint64_t dofh_secoff */" + f_gen_asm ".8byte ${BCOUNT}\t/* uint64_t dofh_loadsz */" + f_gen_asm ".8byte ${BCOUNT}\t/* uint64_t dofh_filesz */" + f_gen_asm ".8byte 0\t/* uint64_t dofh_pad */" + f_gen_asm "" + + # Ok, now assembly the program in OFILE + echo "$asmprogram$asmbody" | $AS -$objbits -o $ofile + + # Next step is to change the sh_type of the ".SUNW_dof" section + # headers to 0x6ffffff4 (SHT_SUNW_dof). + # + # Note that this code relies in the fact that readelf will list + # the sections ordered in the same order than the section headers + # in the section header table of the file. + elfinfo=$($READELF -a $ofile) + + # Mind the endianness. + if printf %s "$elfinfo" | $EGREP -q "little endian"; then + sht_sunw_dof=$(printf %s%s%s%s \\364 \\377 \\377 \\157) + else + sht_sunw_dof=$(printf %s%s%s%s \\157 \\377 \\377 \\364) + fi + + shdr_start=$(printf %s "$elfinfo" \ + | $EGREP "^[ \t]*Start of section headers:" \ + | $SED -E -e 's/.*headers:[ \t]*([0-9]+).*/\1/') + test -n "$shdr_start" \ + || f_panic "could not extract the start of shdr from $ofile" + + shdr_num_entries=$(printf %s "$elfinfo" \ + | $EGREP "^[ \t]*Size of section headers:" \ + | $SED -E -e 's/.*headers:[ \t]*([0-9]+).*/\1/') + test -n "$shdr_num_entries" \ + || f_panic "could not extract the number of shdr entries from $ofile" + + shdr_entry_size=$(printf %s "$elfinfo" \ + | $EGREP "^[ \t]*Size of section headers:" \ + | $SED -E -e 's/.*headers:[ \t]*([0-9]+).*/\1/') + test -n "$shdr_entry_size" \ + || f_panic "could not fetch the size of section headers from $ofile" + + while read line; do + data=$(printf %s "$line" \ + | $SED -E -e 's/.*\[(.*)\][ \t]+([a-zA-Z_.]+).*/\1:\2/') + num=$(printf %s "$data" | $CUT -d: -f1) + name=$(printf %s "$data" | $CUT -d: -f2) + if test "$name" = ".SUNW_dof"; then + # Patch the new sh_type in the proper entry of the section + # header table. + printf "$sht_sunw_dof" \ + | dd of=$ofile conv=notrunc count=4 ibs=1 bs=1 \ + seek=$((shdr_start + (shdr_entry_size * num) + 4)) \ + 2> /dev/null + break + fi + done <<EOF +$(printf %s "$elfinfo" | $EGREP "^[ \t]*\[[0-9 ]+\].*[A-Z]+.*PROGBITS") +EOF + +} + +# Patch the probed points in the given object file, replacing the +# function calls with NOPs. +# +# The probed points in the input object files are function calls. +# This function replaces these function calls by some other +# instruction sequences. Which replacement to use depends on several +# factors, as documented below. +# +# Arguments: +# $1 is the object file to patch. + +f_patch_objfile() +{ + objfile=$1 + + # Several x86_64 instruction opcodes, in octal. + x86_op_nop=$(printf \\220) + x86_op_ret=$(printf \\303) + x86_op_call=$(printf \\350) + x86_op_jmp32=$(printf \\351) + x86_op_rex_rax=$(printf \\110) + x86_op_xor_eax_0=$(printf \\063) + x86_op_xor_eax_1=$(printf \\300) + + # Figure out the file offset of the text section in the object + # file. + text_off=0x$(objdump -j .text -h $objfile \ + | grep \.text | $TR -s ' ' | $CUT -d' ' -f 7) + + while read type provider name offset base base_sym; do + # Calculate the offset of the probed point in the object file. + # Note that the `offset' of is-enabled probes is tweaked in + # `f_collect_probes" to point ahead the patching point. + probe_off=$((text_off + base + offset)) + if test "$type" = "e"; then + if test "$objbits" -eq "32"; then + probe_off=$((probe_off - 2)) + else # 64 bits + probe_off=$((probe_off - 3)) + fi + fi + + # The probed point can be either a CALL instruction or a JMP + # instruction (a tail call). This has an impact on the + # patching sequence. Fetch the first byte at the probed point + # and do the right thing. + nopret="$x86_op_nop" + byte=$(dd if=$objfile count=1 ibs=1 bs=1 skip=$probe_off 2> /dev/null) + test "$byte" = "$x86_op_jmp32" && nopret="$x86_op_ret" + + # Determine the patching sequence. It depends on the type of + # probe at hand (regular or is-enabled) and also if + # manipulating a 32bit or 64bit binary. + patchseq= + case $type in + p) patchseq=$(printf %s%s%s%s%s \ + "$nopret" \ + "$x86_op_nop" \ + "$x86_op_nop" \ + "$x86_op_nop" \ + "$x86_op_nop") + ;; + e) test "$objbits" -eq 64 && \ + patchseq=$(printf %s%s%s%s%s \ + "$x86_op_rex_rax" \ + "$x86_op_xor_eax_0" \ + "$x86_op_xor_eax_1" \ + "$nopret" \ + "$x86_op_nop") + test "$objbits" -eq 32 && \ + patchseq=$(printf %s%s%s%s%s \ + "$x86_op_xor_eax_0" \ + "$x86_op_xor_eax_1" \ + "$nopret" \ + "$x86_op_nop" \ + "$x86_op_nop") + ;; + *) f_panic "internal error: wrong probe type $type";; + esac + + # Patch! + printf %s "$patchseq" \ + | dd of=$objfile conv=notrunc count=5 ibs=1 bs=1 seek=$probe_off 2> /dev/null + done <<EOF +$probes +EOF + + # Finally, we have to remove the __dtrace_* and __dtraceenabled_* + # symbols from the object file, along with their respective + # relocations. + # + # Note that the most obvious call: + # strip -v -N whatever -w foo.o + # will not work: + # strip: not stripping symbol `whatever' because it is named in a relocation + # + # Fortunately using `-K !whatever' instead tricks strip to do the + # right thing, but this is black magic and may eventually stop + # working... + $STRIP -K '!__dtrace_*' -w $objfile + $STRIP -K '!__dtraceenabled_*' -w $objfile +} + +# Read the input .d file and print a header file with macros to +# invoke the probes defined in it. + +f_gen_header_file() +{ + guard=$(basename $ofile | $TR - _ | $CUT -d. -f1 | $TR a-z A-Z) + printf "/*\n * Generated by pdtrace.\n */\n\n" + + printf "#ifndef _${guard}_H\n" + printf "#define _${guard}_H\n\n" + + printf "#include <unistd.h>\n" + printf "#include <inttypes.h>\n" + printf \\n\\n + + printf "#ifdef __cplusplus\nextern \"C\" {\n#endif\n" + + printf "#define _DTRACE_VERSION 1\n\n" + + provider=$(cat $dfile | $EGREP "^ *provider +([a-zA-Z_]+)" \ + | $SED -E -e 's/^ *provider +([a-zA-Z]+).*/\1/') + test -z "$provider" \ + && f_panic "unable to parse the provider name from $dfile." + u_provider=$(printf %s "$provider" | $TR a-z A-Z | $TR -s _) + + cat $dfile | $EGREP "^ *probe +[a-zA-Z_]+ *\(.*\);" | \ + while read line; do + # Extract the probe name. + name=$(printf %s "$line" \ + | $SED -E -e 's/^ *probe +([a-zA-Z_]+).*/\1/') + u_name=$(printf %s "$name" | $TR a-z A-Z | $TR -s _) + + # Generate an arg1,arg2,...,argN line for the probe. + args=""; nargs=0; aline=$(printf %s "$line" | $SED -e 's/.*(\(.*\)).*/\1/') + set -f; IFS=, + for arg in $aline; do + args="${args}arg${nargs}," + nargs=$((nargs + 1)) + done + set +f; unset IFS + args=${args%,} + + echo "#if _DTRACE_VERSION" + echo "" + + # Emit the macros for the probe. + echo "#define ${u_provider}_${u_name}($args) \\" + echo " __dtrace_${provider}___${name}($args)" + echo "#define ${u_provider}_${u_name}_ENABLED() \\" + echo " __dtraceenabled_${provider}___${name}()" + + # Emit the extern definitions for the probe dummy + # functions. + echo "" + printf %s\\n "$line" \ + | $SED -E -e "s/^ *probe +/extern void __dtrace_${provider}___/" + echo "extern int __dtraceenabled_${provider}___${name}(void);" + + + printf "\n#else\n" + + # Emit empty macros for the probe + echo "#define ${u_provider}_${u_name}($args)" + echo "#define ${u_provider}_${u_name}_ENABLED() (0)" + + printf "\n#endif /* _DTRACE_VERSION */\n" + done + + printf "#ifdef __cplusplus\n}\n#endif\n\n" + printf "#endif /* _${guard}_H */\n" +} + +### Main program. + +# Process command line arguments. + +test "$#" -eq "0" && f_usage + +genelf=0 +genheader=0 +objbits=64 +ofile= +dfile= +while getopts VG3264hs:o: name; do + case $name in + V) f_version;; + s) dfile="$OPTARG"; + test -f "$dfile" || f_panic "cannot read $dfile";; + o) ofile="$OPTARG";; + G) genelf=1;; + h) genheader=1;; + # Note the trick to support -32 + 3) objbits=666;; + 2) test "$objbits" -eq 666 || f_usage; objbits=32;; + # Likewise for -64 + 6) objbits=777;; + 4) test "$objbits" -eq 777 || f_usage; objbits=64;; + ?) f_usage;; + esac +done +shift $(($OPTIND - 1)) + +test "$objbits" -eq "32" || test "$objbits" -eq "64" \ + || f_usage + +test $((genelf + genheader)) -gt 1 && \ + { echo "Please use either -G or -h."; f_usage; } + +test -n "$dfile" || { echo "Please specify a .d file with -s."; exit 2; } + +if test "$genelf" -gt 0; then + # In this mode there must be a remaining argument: the name of the + # object file to inspect for probed points. + test "$#" -ne "1" && f_usage + test -f "$1" || f_panic "cannot read $1" + objfile=$1 + + # Collect probe information from the input object file and the + # d-script. + f_collect_probes $objfile + f_collect_probes_args $dfile + + # Generate the assembly code and assemble the DOF program in + # OFILE. Then patch OBJFILE to remove the dummy probe calls. + f_gen_dof_program + f_patch_objfile $objfile +fi + +if test "$genheader" -gt 0; then + test -n "$ofile" || { echo "Please specify an output file with -o."; exit 2; } + + # In this mode no extra arguments shall be present. + test "$#" -ne "0" && f_usage + + f_gen_header_file > $ofile +fi + +# pdtrace ends here. |