| #!/bin/sh |
| # |
| # Code generator for trace events |
| # |
| # Copyright IBM, Corp. 2010 |
| # |
| # This work is licensed under the terms of the GNU GPL, version 2. See |
| # the COPYING file in the top-level directory. |
| |
| # Disable pathname expansion, makes processing text with '*' characters simpler |
| set -f |
| |
| usage() |
| { |
| cat >&2 <<EOF |
| usage: $0 [--nop | --simple | --stderr | --ust | --dtrace] [-h | -c] |
| Generate tracing code for a file on stdin. |
| |
| Backends: |
| --nop Tracing disabled |
| --simple Simple built-in backend |
| --stderr Stderr built-in backend |
| --ust LTTng User Space Tracing backend |
| --dtrace DTrace/SystemTAP backend |
| |
| Output formats: |
| -h Generate .h file |
| -c Generate .c file |
| -d Generate .d file (DTrace only) |
| --stap Generate .stp file (DTrace with SystemTAP only) |
| |
| Options: |
| --binary [path] Full path to QEMU binary |
| --target-arch [arch] QEMU emulator target arch |
| --target-type [type] QEMU emulator target type ('system' or 'user') |
| |
| EOF |
| exit 1 |
| } |
| |
| # Get the name of a trace event |
| get_name() |
| { |
| echo ${1%%\(*} |
| } |
| |
| # Get the argument list of a trace event, including types and names |
| get_args() |
| { |
| local args |
| args=${1#*\(} |
| args=${args%\)*} |
| echo "$args" |
| } |
| |
| # Get the argument name list of a trace event |
| get_argnames() |
| { |
| local nfields field name sep |
| nfields=0 |
| sep="$2" |
| for field in $(get_args "$1"); do |
| nfields=$((nfields + 1)) |
| |
| # Drop pointer star |
| field=${field#\*} |
| |
| # Only argument names have commas at the end |
| name=${field%,} |
| test "$field" = "$name" && continue |
| |
| printf "%s%s " $name $sep |
| done |
| |
| # Last argument name |
| if [ "$nfields" -gt 1 ] |
| then |
| printf "%s" "$name" |
| fi |
| } |
| |
| # Get the number of arguments to a trace event |
| get_argc() |
| { |
| local name argc |
| argc=0 |
| for name in $(get_argnames "$1", ","); do |
| argc=$((argc + 1)) |
| done |
| echo $argc |
| } |
| |
| # Get the format string for a trace event |
| get_fmt() |
| { |
| local fmt |
| fmt=${1#*\"} |
| fmt=${fmt%\"*} |
| echo "$fmt" |
| } |
| |
| # Get the state of a trace event |
| get_state() |
| { |
| local str disable state |
| str=$(get_name "$1") |
| disable=${str##disable } |
| if [ "$disable" = "$str" ] ; then |
| state=1 |
| else |
| state=0 |
| fi |
| echo "$state" |
| } |
| |
| linetoh_begin_nop() |
| { |
| return |
| } |
| |
| linetoh_nop() |
| { |
| local name args |
| name=$(get_name "$1") |
| args=$(get_args "$1") |
| |
| # Define an empty function for the trace event |
| cat <<EOF |
| static inline void trace_$name($args) |
| { |
| } |
| EOF |
| } |
| |
| linetoh_end_nop() |
| { |
| return |
| } |
| |
| linetoc_begin_nop() |
| { |
| return |
| } |
| |
| linetoc_nop() |
| { |
| # No need for function definitions in nop backend |
| return |
| } |
| |
| linetoc_end_nop() |
| { |
| return |
| } |
| |
| linetoh_begin_simple() |
| { |
| cat <<EOF |
| #include "simpletrace.h" |
| EOF |
| |
| simple_event_num=0 |
| } |
| |
| cast_args_to_uint64_t() |
| { |
| local arg |
| for arg in $(get_argnames "$1", ","); do |
| printf "%s" "(uint64_t)(uintptr_t)$arg" |
| done |
| } |
| |
| linetoh_simple() |
| { |
| local name args argc trace_args state |
| name=$(get_name "$1") |
| args=$(get_args "$1") |
| argc=$(get_argc "$1") |
| state=$(get_state "$1") |
| if [ "$state" = "0" ]; then |
| name=${name##disable } |
| fi |
| |
| trace_args="$simple_event_num" |
| if [ "$argc" -gt 0 ] |
| then |
| trace_args="$trace_args, $(cast_args_to_uint64_t "$1")" |
| fi |
| |
| cat <<EOF |
| static inline void trace_$name($args) |
| { |
| trace$argc($trace_args); |
| } |
| EOF |
| |
| simple_event_num=$((simple_event_num + 1)) |
| } |
| |
| linetoh_end_simple() |
| { |
| cat <<EOF |
| #define NR_TRACE_EVENTS $simple_event_num |
| extern TraceEvent trace_list[NR_TRACE_EVENTS]; |
| EOF |
| } |
| |
| linetoc_begin_simple() |
| { |
| cat <<EOF |
| #include "trace.h" |
| |
| TraceEvent trace_list[] = { |
| EOF |
| simple_event_num=0 |
| |
| } |
| |
| linetoc_simple() |
| { |
| local name state |
| name=$(get_name "$1") |
| state=$(get_state "$1") |
| if [ "$state" = "0" ] ; then |
| name=${name##disable } |
| fi |
| cat <<EOF |
| {.tp_name = "$name", .state=$state}, |
| EOF |
| simple_event_num=$((simple_event_num + 1)) |
| } |
| |
| linetoc_end_simple() |
| { |
| cat <<EOF |
| }; |
| EOF |
| } |
| |
| #STDERR |
| linetoh_begin_stderr() |
| { |
| cat <<EOF |
| #include <stdio.h> |
| EOF |
| } |
| |
| linetoh_stderr() |
| { |
| local name args argnames argc fmt |
| name=$(get_name "$1") |
| args=$(get_args "$1") |
| argnames=$(get_argnames "$1" ",") |
| argc=$(get_argc "$1") |
| fmt=$(get_fmt "$1") |
| |
| if [ "$argc" -gt 0 ]; then |
| argnames=", $argnames" |
| fi |
| |
| cat <<EOF |
| static inline void trace_$name($args) |
| { |
| fprintf(stderr, "$name $fmt\n" $argnames); |
| } |
| EOF |
| } |
| |
| linetoh_end_stderr() |
| { |
| return |
| } |
| |
| linetoc_begin_stderr() |
| { |
| return |
| } |
| |
| linetoc_stderr() |
| { |
| return |
| } |
| |
| linetoc_end_stderr() |
| { |
| return |
| } |
| #END OF STDERR |
| |
| # Clean up after UST headers which pollute the namespace |
| ust_clean_namespace() { |
| cat <<EOF |
| #undef mutex_lock |
| #undef mutex_unlock |
| #undef inline |
| #undef wmb |
| EOF |
| } |
| |
| linetoh_begin_ust() |
| { |
| echo "#include <ust/tracepoint.h>" |
| ust_clean_namespace |
| } |
| |
| linetoh_ust() |
| { |
| local name args argnames |
| name=$(get_name "$1") |
| args=$(get_args "$1") |
| argnames=$(get_argnames "$1", ",") |
| |
| cat <<EOF |
| DECLARE_TRACE(ust_$name, TP_PROTO($args), TP_ARGS($argnames)); |
| #define trace_$name trace_ust_$name |
| EOF |
| } |
| |
| linetoh_end_ust() |
| { |
| return |
| } |
| |
| linetoc_begin_ust() |
| { |
| cat <<EOF |
| #include <ust/marker.h> |
| $(ust_clean_namespace) |
| #include "trace.h" |
| EOF |
| } |
| |
| linetoc_ust() |
| { |
| local name args argnames fmt |
| name=$(get_name "$1") |
| args=$(get_args "$1") |
| argnames=$(get_argnames "$1", ",") |
| fmt=$(get_fmt "$1") |
| |
| cat <<EOF |
| DEFINE_TRACE(ust_$name); |
| |
| static void ust_${name}_probe($args) |
| { |
| trace_mark(ust, $name, "$fmt", $argnames); |
| } |
| EOF |
| |
| # Collect names for later |
| names="$names $name" |
| } |
| |
| linetoc_end_ust() |
| { |
| cat <<EOF |
| static void __attribute__((constructor)) trace_init(void) |
| { |
| EOF |
| |
| for name in $names; do |
| cat <<EOF |
| register_trace_ust_$name(ust_${name}_probe); |
| EOF |
| done |
| |
| echo "}" |
| } |
| |
| linetoh_begin_dtrace() |
| { |
| cat <<EOF |
| #include "trace-dtrace.h" |
| EOF |
| } |
| |
| linetoh_dtrace() |
| { |
| local name args argnames state nameupper |
| name=$(get_name "$1") |
| args=$(get_args "$1") |
| argnames=$(get_argnames "$1", ",") |
| state=$(get_state "$1") |
| if [ "$state" = "0" ] ; then |
| name=${name##disable } |
| fi |
| |
| nameupper=`echo $name | tr '[:lower:]' '[:upper:]'` |
| |
| # Define an empty function for the trace event |
| cat <<EOF |
| static inline void trace_$name($args) { |
| if (QEMU_${nameupper}_ENABLED()) { |
| QEMU_${nameupper}($argnames); |
| } |
| } |
| EOF |
| } |
| |
| linetoh_end_dtrace() |
| { |
| return |
| } |
| |
| linetoc_begin_dtrace() |
| { |
| return |
| } |
| |
| linetoc_dtrace() |
| { |
| # No need for function definitions in dtrace backend |
| return |
| } |
| |
| linetoc_end_dtrace() |
| { |
| return |
| } |
| |
| linetod_begin_dtrace() |
| { |
| cat <<EOF |
| provider qemu { |
| EOF |
| } |
| |
| linetod_dtrace() |
| { |
| local name args state |
| name=$(get_name "$1") |
| args=$(get_args "$1") |
| state=$(get_state "$1") |
| if [ "$state" = "0" ] ; then |
| name=${name##disable } |
| fi |
| |
| # DTrace provider syntax expects foo() for empty |
| # params, not foo(void) |
| if [ "$args" = "void" ]; then |
| args="" |
| fi |
| |
| # Define prototype for probe arguments |
| cat <<EOF |
| probe $name($args); |
| EOF |
| } |
| |
| linetod_end_dtrace() |
| { |
| cat <<EOF |
| }; |
| EOF |
| } |
| |
| linetostap_begin_dtrace() |
| { |
| return |
| } |
| |
| linetostap_dtrace() |
| { |
| local i arg name args arglist state |
| name=$(get_name "$1") |
| args=$(get_args "$1") |
| arglist=$(get_argnames "$1", "") |
| state=$(get_state "$1") |
| if [ "$state" = "0" ] ; then |
| name=${name##disable } |
| fi |
| |
| # Define prototype for probe arguments |
| cat <<EOF |
| probe qemu.$targettype.$targetarch.$name = process("$binary").mark("$name") |
| { |
| EOF |
| |
| i=1 |
| for arg in $arglist |
| do |
| # 'limit' is a reserved keyword |
| if [ "$arg" = "limit" ]; then |
| arg="_limit" |
| fi |
| cat <<EOF |
| $arg = \$arg$i; |
| EOF |
| i="$((i+1))" |
| done |
| |
| cat <<EOF |
| } |
| EOF |
| } |
| |
| linetostap_end_dtrace() |
| { |
| return |
| } |
| |
| # Process stdin by calling begin, line, and end functions for the backend |
| convert() |
| { |
| local begin process_line end str disable |
| begin="lineto$1_begin_$backend" |
| process_line="lineto$1_$backend" |
| end="lineto$1_end_$backend" |
| |
| "$begin" |
| |
| while read -r str; do |
| # Skip comments and empty lines |
| test -z "${str%%#*}" && continue |
| |
| # Process the line. The nop backend handles disabled lines. |
| disable=${str%%disable *} |
| echo |
| if test -z "$disable"; then |
| # Pass the disabled state as an arg for the simple |
| # or DTrace backends which handle it dynamically. |
| # For all other backends, call lineto$1_nop() |
| if [ $backend = "simple" -o "$backend" = "dtrace" ]; then |
| "$process_line" "$str" |
| else |
| "lineto$1_nop" "${str##disable }" |
| fi |
| else |
| "$process_line" "$str" |
| fi |
| done |
| |
| echo |
| "$end" |
| } |
| |
| tracetoh() |
| { |
| cat <<EOF |
| #ifndef TRACE_H |
| #define TRACE_H |
| |
| /* This file is autogenerated by tracetool, do not edit. */ |
| |
| #include "qemu-common.h" |
| EOF |
| convert h |
| echo "#endif /* TRACE_H */" |
| } |
| |
| tracetoc() |
| { |
| echo "/* This file is autogenerated by tracetool, do not edit. */" |
| convert c |
| } |
| |
| tracetod() |
| { |
| if [ $backend != "dtrace" ]; then |
| echo "DTrace probe generator not applicable to $backend backend" |
| exit 1 |
| fi |
| echo "/* This file is autogenerated by tracetool, do not edit. */" |
| convert d |
| } |
| |
| tracetostap() |
| { |
| if [ $backend != "dtrace" ]; then |
| echo "SystemTAP tapset generator not applicable to $backend backend" |
| exit 1 |
| fi |
| if [ -z "$binary" ]; then |
| echo "--binary is required for SystemTAP tapset generator" |
| exit 1 |
| fi |
| if [ -z "$targettype" ]; then |
| echo "--target-type is required for SystemTAP tapset generator" |
| exit 1 |
| fi |
| if [ -z "$targetarch" ]; then |
| echo "--target-arch is required for SystemTAP tapset generator" |
| exit 1 |
| fi |
| echo "/* This file is autogenerated by tracetool, do not edit. */" |
| convert stap |
| } |
| |
| |
| backend= |
| output= |
| binary= |
| targettype= |
| targetarch= |
| |
| |
| until [ -z "$1" ] |
| do |
| case "$1" in |
| "--nop" | "--simple" | "--stderr" | "--ust" | "--dtrace") backend="${1#--}" ;; |
| |
| "--binary") shift ; binary="$1" ;; |
| "--target-arch") shift ; targetarch="$1" ;; |
| "--target-type") shift ; targettype="$1" ;; |
| |
| "-h" | "-c" | "-d") output="${1#-}" ;; |
| "--stap") output="${1#--}" ;; |
| |
| "--check-backend") exit 0 ;; # used by ./configure to test for backend |
| |
| "--list-backends") # used by ./configure to list available backends |
| echo "nop simple stderr ust dtrace" |
| exit 0 |
| ;; |
| |
| *) |
| usage;; |
| esac |
| shift |
| done |
| |
| if [ "$backend" = "" -o "$output" = "" ]; then |
| usage |
| fi |
| |
| gen="traceto$output" |
| "$gen" |
| |
| exit 0 |