Return to tracetool CVS log

Up to [Qemu by Fabrice Bellard] / qemu / scripts

Annotation of qemu/scripts/tracetool, revision 1.1

1.1     ! root        1: #!/bin/sh
        !             2: #
        !             3: # Code generator for trace events
        !             4: #
        !             5: # Copyright IBM, Corp. 2010
        !             6: #
        !             7: # This work is licensed under the terms of the GNU GPL, version 2.  See
        !             8: # the COPYING file in the top-level directory.
        !             9: 
        !            10: # Disable pathname expansion, makes processing text with '*' characters simpler
        !            11: set -f
        !            12: 
        !            13: usage()
        !            14: {
        !            15:     cat >&2 <<EOF
        !            16: usage: $0 [--nop | --simple | --stderr | --ust | --dtrace] [-h | -c]
        !            17: Generate tracing code for a file on stdin.
        !            18: 
        !            19: Backends:
        !            20:   --nop     Tracing disabled
        !            21:   --simple  Simple built-in backend
        !            22:   --stderr  Stderr built-in backend
        !            23:   --ust     LTTng User Space Tracing backend
        !            24:   --dtrace  DTrace/SystemTAP backend
        !            25: 
        !            26: Output formats:
        !            27:   -h     Generate .h file
        !            28:   -c     Generate .c file
        !            29:   -d     Generate .d file (DTrace only)
        !            30:   --stap Generate .stp file (DTrace with SystemTAP only)
        !            31: 
        !            32: Options:
        !            33:   --binary      [path]  Full path to QEMU binary
        !            34:   --target-arch [arch]  QEMU emulator target arch
        !            35:   --target-type [type]  QEMU emulator target type ('system' or 'user')
        !            36: 
        !            37: EOF
        !            38:     exit 1
        !            39: }
        !            40: 
        !            41: # Get the name of a trace event
        !            42: get_name()
        !            43: {
        !            44:     echo ${1%%\(*}
        !            45: }
        !            46: 
        !            47: # Get the argument list of a trace event, including types and names
        !            48: get_args()
        !            49: {
        !            50:     local args
        !            51:     args=${1#*\(}
        !            52:     args=${args%\)*}
        !            53:     echo "$args"
        !            54: }
        !            55: 
        !            56: # Get the argument name list of a trace event
        !            57: get_argnames()
        !            58: {
        !            59:     local nfields field name sep
        !            60:     nfields=0
        !            61:     sep="$2"
        !            62:     for field in $(get_args "$1"); do
        !            63:         nfields=$((nfields + 1))
        !            64: 
        !            65:         # Drop pointer star
        !            66:         field=${field#\*}
        !            67: 
        !            68:         # Only argument names have commas at the end
        !            69:         name=${field%,}
        !            70:         test "$field" = "$name" && continue
        !            71: 
        !            72:         printf "%s%s " $name $sep
        !            73:     done
        !            74: 
        !            75:     # Last argument name
        !            76:     if [ "$nfields" -gt 1 ]
        !            77:     then
        !            78:         printf "%s" "$name"
        !            79:     fi
        !            80: }
        !            81: 
        !            82: # Get the number of arguments to a trace event
        !            83: get_argc()
        !            84: {
        !            85:     local name argc
        !            86:     argc=0
        !            87:     for name in $(get_argnames "$1", ","); do
        !            88:         argc=$((argc + 1))
        !            89:     done
        !            90:     echo $argc
        !            91: }
        !            92: 
        !            93: # Get the format string for a trace event
        !            94: get_fmt()
        !            95: {
        !            96:     local fmt
        !            97:     fmt=${1#*\"}
        !            98:     fmt=${fmt%\"*}
        !            99:     echo "$fmt"
        !           100: }
        !           101: 
        !           102: # Get the state of a trace event
        !           103: get_state()
        !           104: {
        !           105:     local str disable state
        !           106:     str=$(get_name "$1")
        !           107:     disable=${str##disable }
        !           108:     if [ "$disable" = "$str" ] ; then
        !           109:         state=1
        !           110:     else
        !           111:         state=0
        !           112:     fi
        !           113:     echo "$state"
        !           114: }
        !           115: 
        !           116: linetoh_begin_nop()
        !           117: {
        !           118:     return
        !           119: }
        !           120: 
        !           121: linetoh_nop()
        !           122: {
        !           123:     local name args
        !           124:     name=$(get_name "$1")
        !           125:     args=$(get_args "$1")
        !           126: 
        !           127:     # Define an empty function for the trace event
        !           128:     cat <<EOF
        !           129: static inline void trace_$name($args)
        !           130: {
        !           131: }
        !           132: EOF
        !           133: }
        !           134: 
        !           135: linetoh_end_nop()
        !           136: {
        !           137:     return
        !           138: }
        !           139: 
        !           140: linetoc_begin_nop()
        !           141: {
        !           142:     return
        !           143: }
        !           144: 
        !           145: linetoc_nop()
        !           146: {
        !           147:     # No need for function definitions in nop backend
        !           148:     return
        !           149: }
        !           150: 
        !           151: linetoc_end_nop()
        !           152: {
        !           153:     return
        !           154: }
        !           155: 
        !           156: linetoh_begin_simple()
        !           157: {
        !           158:     cat <<EOF
        !           159: #include "simpletrace.h"
        !           160: EOF
        !           161: 
        !           162:     simple_event_num=0
        !           163: }
        !           164: 
        !           165: cast_args_to_uint64_t()
        !           166: {
        !           167:     local arg
        !           168:     for arg in $(get_argnames "$1", ","); do
        !           169:         printf "%s" "(uint64_t)(uintptr_t)$arg"
        !           170:     done
        !           171: }
        !           172: 
        !           173: linetoh_simple()
        !           174: {
        !           175:     local name args argc trace_args state
        !           176:     name=$(get_name "$1")
        !           177:     args=$(get_args "$1")
        !           178:     argc=$(get_argc "$1")
        !           179:     state=$(get_state "$1")
        !           180:     if [ "$state" = "0" ]; then
        !           181:         name=${name##disable }
        !           182:     fi
        !           183: 
        !           184:     trace_args="$simple_event_num"
        !           185:     if [ "$argc" -gt 0 ]
        !           186:     then
        !           187:         trace_args="$trace_args, $(cast_args_to_uint64_t "$1")"
        !           188:     fi
        !           189: 
        !           190:     cat <<EOF
        !           191: static inline void trace_$name($args)
        !           192: {
        !           193:     trace$argc($trace_args);
        !           194: }
        !           195: EOF
        !           196: 
        !           197:     simple_event_num=$((simple_event_num + 1))
        !           198: }
        !           199: 
        !           200: linetoh_end_simple()
        !           201: {
        !           202:     cat <<EOF
        !           203: #define NR_TRACE_EVENTS $simple_event_num
        !           204: extern TraceEvent trace_list[NR_TRACE_EVENTS];
        !           205: EOF
        !           206: }
        !           207: 
        !           208: linetoc_begin_simple()
        !           209: {
        !           210:     cat <<EOF
        !           211: #include "trace.h"
        !           212: 
        !           213: TraceEvent trace_list[] = {
        !           214: EOF
        !           215:     simple_event_num=0
        !           216: 
        !           217: }
        !           218: 
        !           219: linetoc_simple()
        !           220: {
        !           221:     local name state
        !           222:     name=$(get_name "$1")
        !           223:     state=$(get_state "$1")
        !           224:     if [ "$state" = "0" ] ; then
        !           225:         name=${name##disable }
        !           226:     fi
        !           227:     cat <<EOF
        !           228: {.tp_name = "$name", .state=$state},
        !           229: EOF
        !           230:     simple_event_num=$((simple_event_num + 1))
        !           231: }
        !           232: 
        !           233: linetoc_end_simple()
        !           234: {
        !           235:     cat <<EOF
        !           236: };
        !           237: EOF
        !           238: }
        !           239: 
        !           240: #STDERR
        !           241: linetoh_begin_stderr()
        !           242: {
        !           243:     cat <<EOF
        !           244: #include <stdio.h>
        !           245: EOF
        !           246: }
        !           247: 
        !           248: linetoh_stderr()
        !           249: {
        !           250:     local name args argnames argc fmt
        !           251:     name=$(get_name "$1")
        !           252:     args=$(get_args "$1")
        !           253:     argnames=$(get_argnames "$1" ",")
        !           254:     argc=$(get_argc "$1")
        !           255:     fmt=$(get_fmt "$1")
        !           256: 
        !           257:     if [ "$argc" -gt 0 ]; then
        !           258:         argnames=", $argnames"
        !           259:     fi
        !           260: 
        !           261:     cat <<EOF
        !           262: static inline void trace_$name($args)
        !           263: {
        !           264:     fprintf(stderr, "$name $fmt\n" $argnames);
        !           265: }
        !           266: EOF
        !           267: }
        !           268: 
        !           269: linetoh_end_stderr()
        !           270: {
        !           271: return
        !           272: }
        !           273: 
        !           274: linetoc_begin_stderr()
        !           275: {
        !           276: return
        !           277: }
        !           278: 
        !           279: linetoc_stderr()
        !           280: {
        !           281: return
        !           282: }
        !           283: 
        !           284: linetoc_end_stderr()
        !           285: {
        !           286: return
        !           287: }
        !           288: #END OF STDERR
        !           289: 
        !           290: # Clean up after UST headers which pollute the namespace
        !           291: ust_clean_namespace() {
        !           292:     cat <<EOF
        !           293: #undef mutex_lock
        !           294: #undef mutex_unlock
        !           295: #undef inline
        !           296: #undef wmb
        !           297: EOF
        !           298: }
        !           299: 
        !           300: linetoh_begin_ust()
        !           301: {
        !           302:     echo "#include <ust/tracepoint.h>"
        !           303:     ust_clean_namespace
        !           304: }
        !           305: 
        !           306: linetoh_ust()
        !           307: {
        !           308:     local name args argnames
        !           309:     name=$(get_name "$1")
        !           310:     args=$(get_args "$1")
        !           311:     argnames=$(get_argnames "$1", ",")
        !           312: 
        !           313:     cat <<EOF
        !           314: DECLARE_TRACE(ust_$name, TP_PROTO($args), TP_ARGS($argnames));
        !           315: #define trace_$name trace_ust_$name
        !           316: EOF
        !           317: }
        !           318: 
        !           319: linetoh_end_ust()
        !           320: {
        !           321:     return
        !           322: }
        !           323: 
        !           324: linetoc_begin_ust()
        !           325: {
        !           326:     cat <<EOF
        !           327: #include <ust/marker.h>
        !           328: $(ust_clean_namespace)
        !           329: #include "trace.h"
        !           330: EOF
        !           331: }
        !           332: 
        !           333: linetoc_ust()
        !           334: {
        !           335:     local name args argnames fmt
        !           336:     name=$(get_name "$1")
        !           337:     args=$(get_args "$1")
        !           338:     argnames=$(get_argnames "$1", ",")
        !           339:     fmt=$(get_fmt "$1")
        !           340: 
        !           341:     cat <<EOF
        !           342: DEFINE_TRACE(ust_$name);
        !           343: 
        !           344: static void ust_${name}_probe($args)
        !           345: {
        !           346:     trace_mark(ust, $name, "$fmt", $argnames);
        !           347: }
        !           348: EOF
        !           349: 
        !           350:     # Collect names for later
        !           351:     names="$names $name"
        !           352: }
        !           353: 
        !           354: linetoc_end_ust()
        !           355: {
        !           356:     cat <<EOF
        !           357: static void __attribute__((constructor)) trace_init(void)
        !           358: {
        !           359: EOF
        !           360: 
        !           361:     for name in $names; do
        !           362:         cat <<EOF
        !           363:     register_trace_ust_$name(ust_${name}_probe);
        !           364: EOF
        !           365:     done
        !           366: 
        !           367:     echo "}"
        !           368: }
        !           369: 
        !           370: linetoh_begin_dtrace()
        !           371: {
        !           372:     cat <<EOF
        !           373: #include "trace-dtrace.h"
        !           374: EOF
        !           375: }
        !           376: 
        !           377: linetoh_dtrace()
        !           378: {
        !           379:     local name args argnames state nameupper
        !           380:     name=$(get_name "$1")
        !           381:     args=$(get_args "$1")
        !           382:     argnames=$(get_argnames "$1", ",")
        !           383:     state=$(get_state "$1")
        !           384:     if [ "$state" = "0" ] ; then
        !           385:         name=${name##disable }
        !           386:     fi
        !           387: 
        !           388:     nameupper=`echo $name | tr '[:lower:]' '[:upper:]'`
        !           389: 
        !           390:     # Define an empty function for the trace event
        !           391:     cat <<EOF
        !           392: static inline void trace_$name($args) {
        !           393:     if (QEMU_${nameupper}_ENABLED()) {
        !           394:         QEMU_${nameupper}($argnames);
        !           395:     }
        !           396: }
        !           397: EOF
        !           398: }
        !           399: 
        !           400: linetoh_end_dtrace()
        !           401: {
        !           402:     return
        !           403: }
        !           404: 
        !           405: linetoc_begin_dtrace()
        !           406: {
        !           407:     return
        !           408: }
        !           409: 
        !           410: linetoc_dtrace()
        !           411: {
        !           412:     # No need for function definitions in dtrace backend
        !           413:     return
        !           414: }
        !           415: 
        !           416: linetoc_end_dtrace()
        !           417: {
        !           418:     return
        !           419: }
        !           420: 
        !           421: linetod_begin_dtrace()
        !           422: {
        !           423:     cat <<EOF
        !           424: provider qemu {
        !           425: EOF
        !           426: }
        !           427: 
        !           428: linetod_dtrace()
        !           429: {
        !           430:     local name args state
        !           431:     name=$(get_name "$1")
        !           432:     args=$(get_args "$1")
        !           433:     state=$(get_state "$1")
        !           434:     if [ "$state" = "0" ] ; then
        !           435:         name=${name##disable }
        !           436:     fi
        !           437: 
        !           438:     # DTrace provider syntax expects foo() for empty
        !           439:     # params, not foo(void)
        !           440:     if [ "$args" = "void" ]; then
        !           441:        args=""
        !           442:     fi
        !           443: 
        !           444:     # Define prototype for probe arguments
        !           445:     cat <<EOF
        !           446:         probe $name($args);
        !           447: EOF
        !           448: }
        !           449: 
        !           450: linetod_end_dtrace()
        !           451: {
        !           452:     cat <<EOF
        !           453: };
        !           454: EOF
        !           455: }
        !           456: 
        !           457: linetostap_begin_dtrace()
        !           458: {
        !           459:     return
        !           460: }
        !           461: 
        !           462: linetostap_dtrace()
        !           463: {
        !           464:     local i arg name args arglist state
        !           465:     name=$(get_name "$1")
        !           466:     args=$(get_args "$1")
        !           467:     arglist=$(get_argnames "$1", "")
        !           468:     state=$(get_state "$1")
        !           469:     if [ "$state" = "0" ] ; then
        !           470:         name=${name##disable }
        !           471:     fi
        !           472: 
        !           473:     # Define prototype for probe arguments
        !           474:     cat <<EOF
        !           475: probe qemu.$targettype.$targetarch.$name = process("$binary").mark("$name")
        !           476: {
        !           477: EOF
        !           478: 
        !           479:     i=1
        !           480:     for arg in $arglist
        !           481:     do
        !           482:         # 'limit' is a reserved keyword
        !           483:         if [ "$arg" = "limit" ]; then
        !           484:           arg="_limit"
        !           485:         fi
        !           486:         cat <<EOF
        !           487:   $arg = \$arg$i;
        !           488: EOF
        !           489:        i="$((i+1))"
        !           490:     done
        !           491: 
        !           492:     cat <<EOF
        !           493: }
        !           494: EOF
        !           495: }
        !           496: 
        !           497: linetostap_end_dtrace()
        !           498: {
        !           499:     return
        !           500: }
        !           501: 
        !           502: # Process stdin by calling begin, line, and end functions for the backend
        !           503: convert()
        !           504: {
        !           505:     local begin process_line end str disable
        !           506:     begin="lineto$1_begin_$backend"
        !           507:     process_line="lineto$1_$backend"
        !           508:     end="lineto$1_end_$backend"
        !           509: 
        !           510:     "$begin"
        !           511: 
        !           512:     while read -r str; do
        !           513:         # Skip comments and empty lines
        !           514:         test -z "${str%%#*}" && continue
        !           515: 
        !           516:         # Process the line.  The nop backend handles disabled lines.
        !           517:         disable=${str%%disable *}
        !           518:         echo
        !           519:         if test -z "$disable"; then
        !           520:             # Pass the disabled state as an arg for the simple
        !           521:             # or DTrace backends which handle it dynamically.
        !           522:             # For all other backends, call lineto$1_nop()
        !           523:             if [ $backend = "simple" -o "$backend" = "dtrace" ]; then
        !           524:                 "$process_line" "$str"
        !           525:             else
        !           526:                 "lineto$1_nop" "${str##disable }"
        !           527:             fi
        !           528:         else
        !           529:             "$process_line" "$str"
        !           530:         fi
        !           531:     done
        !           532: 
        !           533:     echo
        !           534:     "$end"
        !           535: }
        !           536: 
        !           537: tracetoh()
        !           538: {
        !           539:     cat <<EOF
        !           540: #ifndef TRACE_H
        !           541: #define TRACE_H
        !           542: 
        !           543: /* This file is autogenerated by tracetool, do not edit. */
        !           544: 
        !           545: #include "qemu-common.h"
        !           546: EOF
        !           547:     convert h
        !           548:     echo "#endif /* TRACE_H */"
        !           549: }
        !           550: 
        !           551: tracetoc()
        !           552: {
        !           553:     echo "/* This file is autogenerated by tracetool, do not edit. */"
        !           554:     convert c
        !           555: }
        !           556: 
        !           557: tracetod()
        !           558: {
        !           559:     if [ $backend != "dtrace" ]; then
        !           560:        echo "DTrace probe generator not applicable to $backend backend"
        !           561:        exit 1
        !           562:     fi
        !           563:     echo "/* This file is autogenerated by tracetool, do not edit. */"
        !           564:     convert d
        !           565: }
        !           566: 
        !           567: tracetostap()
        !           568: {
        !           569:     if [ $backend != "dtrace" ]; then
        !           570:        echo "SystemTAP tapset generator not applicable to $backend backend"
        !           571:        exit 1
        !           572:     fi
        !           573:     if [ -z "$binary" ]; then
        !           574:        echo "--binary is required for SystemTAP tapset generator"
        !           575:        exit 1
        !           576:     fi
        !           577:     if [ -z "$targettype" ]; then
        !           578:        echo "--target-type is required for SystemTAP tapset generator"
        !           579:        exit 1
        !           580:     fi
        !           581:     if [ -z "$targetarch" ]; then
        !           582:        echo "--target-arch is required for SystemTAP tapset generator"
        !           583:        exit 1
        !           584:     fi
        !           585:     echo "/* This file is autogenerated by tracetool, do not edit. */"
        !           586:     convert stap
        !           587: }
        !           588: 
        !           589: 
        !           590: backend=
        !           591: output=
        !           592: binary=
        !           593: targettype=
        !           594: targetarch=
        !           595: 
        !           596: 
        !           597: until [ -z "$1" ]
        !           598: do
        !           599:   case "$1" in
        !           600:     "--nop" | "--simple" | "--stderr" | "--ust" | "--dtrace") backend="${1#--}" ;;
        !           601: 
        !           602:     "--binary") shift ; binary="$1" ;;
        !           603:     "--target-arch") shift ; targetarch="$1" ;;
        !           604:     "--target-type") shift ; targettype="$1" ;;
        !           605: 
        !           606:     "-h" | "-c" | "-d") output="${1#-}" ;;
        !           607:     "--stap") output="${1#--}" ;;
        !           608: 
        !           609:     "--check-backend") exit 0 ;; # used by ./configure to test for backend
        !           610: 
        !           611:     "--list-backends") # used by ./configure to list available backends
        !           612:           echo "nop simple stderr ust dtrace"
        !           613:           exit 0
        !           614:           ;;
        !           615: 
        !           616:     *)
        !           617:       usage;;
        !           618:   esac
        !           619:   shift
        !           620: done
        !           621: 
        !           622: if [ "$backend" = "" -o "$output" = "" ]; then
        !           623:   usage
        !           624: fi
        !           625: 
        !           626: gen="traceto$output"
        !           627: "$gen"
        !           628: 
        !           629: exit 0

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.