Archipelago » qemu

#!/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')

  --probe-prefix [prefix]  Prefix for dtrace probe names

                           (default: qemu-\$targettype-\$targetarch)

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 $probeprefix.$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 "$probeprefix" -a -z "$targettype" ]; then

       echo "--target-type is required for SystemTAP tapset generator"

       exit 1

    fi

    if [ -z "$probeprefix" -a -z "$targetarch" ]; then

       echo "--target-arch is required for SystemTAP tapset generator"

       exit 1

    fi

    if [ -z "$probeprefix" ]; then

	probeprefix="qemu.$targettype.$targetarch";

    fi

    echo "/* This file is autogenerated by tracetool, do not edit. */"

    convert stap

}

backend=

output=

binary=

targettype=

targetarch=

probeprefix=

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" ;;

    "--probe-prefix") shift ; probeprefix="$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