Skip to content

Q
qemu

openeuler / qemu

通知 10
Star 0
Fork 0
Q
qemu

体验新版 GitCode，发现更多精彩内容 >>

提交 e5e38957 编写于 作者: A Anthony Liguori
浏览文件
操作

Merge remote-tracking branch 'stefanha/tracing' into staging 

* stefanha/tracing:
  tracetool: handle DTrace keywords 'in', 'next', 'self'
  tracetool: Add MAINTAINERS info
  tracetool: Add support for the 'dtrace' backend
  tracetool: Add support for the 'ust' backend
  tracetool: Add support for the 'simple' backend
  tracetool: Add support for the 'stderr' backend
  tracetool: Add module for the 'h' format
  tracetool: Add module for the 'c' format
  tracetool: Rewrite infrastructure as python modules
上级 51006bbc 256a721d
隐藏空白更改
内联 并排
Showing with 1036 addition and 677 deletion
MAINTAINERS
浏览文件 @ e5e38957
......@@ -553,6 +553,8 @@ Tracing
M: Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
S: Maintained
F: trace/
F: scripts/tracetool.py
F: scripts/tracetool/
F: docs/tracing.txt
T: git://github.com/stefanha/qemu.git tracing
......
Makefile.objs
浏览文件 @ e5e38957
......@@ -378,12 +378,12 @@ else
trace.h: trace.h-timestamp
endif
trace.h-timestamp: $(SRC_PATH)/trace-events $(BUILD_DIR)/config-host.mak
$(call quiet-command,sh $(SRC_PATH)/scripts/tracetool --$(TRACE_BACKEND) -h < $< > $@," GEN trace.h")
$(call quiet-command,$(PYTHON) $(SRC_PATH)/scripts/tracetool.py --format=h --backend=$(TRACE_BACKEND) < $< > $@," GEN trace.h")
@cmp -s $@ trace.h || cp $@ trace.h
trace.c: trace.c-timestamp
trace.c-timestamp: $(SRC_PATH)/trace-events $(BUILD_DIR)/config-host.mak
$(call quiet-command,sh $(SRC_PATH)/scripts/tracetool --$(TRACE_BACKEND) -c < $< > $@," GEN trace.c")
$(call quiet-command,$(PYTHON) $(SRC_PATH)/scripts/tracetool.py --format=c --backend=$(TRACE_BACKEND) < $< > $@," GEN trace.c")
@cmp -s $@ trace.c || cp $@ trace.c
trace.o: trace.c $(GENERATED_HEADERS)
......@@ -396,7 +396,7 @@ trace-dtrace.h: trace-dtrace.dtrace
# rule file. So we use '.dtrace' instead
trace-dtrace.dtrace: trace-dtrace.dtrace-timestamp
trace-dtrace.dtrace-timestamp: $(SRC_PATH)/trace-events $(BUILD_DIR)/config-host.mak
$(call quiet-command,sh $(SRC_PATH)/scripts/tracetool --$(TRACE_BACKEND) -d < $< > $@," GEN trace-dtrace.dtrace")
$(call quiet-command,$(PYTHON) $(SRC_PATH)/scripts/tracetool.py --format=d --backend=$(TRACE_BACKEND) < $< > $@," GEN trace-dtrace.dtrace")
@cmp -s $@ trace-dtrace.dtrace || cp $@ trace-dtrace.dtrace
trace-dtrace.o: trace-dtrace.dtrace $(GENERATED_HEADERS)
......
Makefile.target
浏览文件 @ e5e38957
......@@ -59,12 +59,13 @@ TARGET_TYPE=system
endif
$(QEMU_PROG).stp: $(SRC_PATH)/trace-events
$(call quiet-command,sh $(SRC_PATH)/scripts/tracetool \
--$(TRACE_BACKEND) \
--binary $(bindir)/$(QEMU_PROG) \
--target-arch $(TARGET_ARCH) \
--target-type $(TARGET_TYPE) \
--stap < $(SRC_PATH)/trace-events > $(QEMU_PROG).stp," GEN $(QEMU_PROG).stp")
$(call quiet-command,$(PYTHON) $(SRC_PATH)/scripts/tracetool.py \
--format=stap \
--backend=$(TRACE_BACKEND) \
--binary=$(bindir)/$(QEMU_PROG) \
--target-arch=$(TARGET_ARCH) \
--target-type=$(TARGET_TYPE) \
< $(SRC_PATH)/trace-events > $(QEMU_PROG).stp," GEN $(QEMU_PROG).stp")
else
stap:
endif
......
configure
浏览文件 @ e5e38957
......@@ -1097,7 +1097,7 @@ echo " --disable-docs disable documentation build"
echo " --disable-vhost-net disable vhost-net acceleration support"
echo " --enable-vhost-net enable vhost-net acceleration support"
echo " --enable-trace-backend=B Set trace backend"
echo " Available backends:" $("$source_path"/scripts/tracetool --list-backends)
echo " Available backends:" $($python "$source_path"/scripts/tracetool.py --list-backends)
echo " --with-trace-file=NAME Full PATH,NAME of file to store traces"
echo " Default:trace-<pid>"
echo " --disable-spice disable spice"
......@@ -2670,7 +2670,7 @@ fi
##########################################
# check if trace backend exists
sh "$source_path/scripts/tracetool" "--$trace_backend" --check-backend > /dev/null 2> /dev/null
$python "$source_path/scripts/tracetool.py" "--backend=$trace_backend" --check-backend > /dev/null 2> /dev/null
if test "$?" -ne 0 ; then
echo
echo "Error: invalid trace backend"
......
scripts/tracetool 已删除 100755 → 0
浏览文件 @ 51006bbc
#!/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
}
# Print a line without interpreting backslash escapes
#
# The built-in echo command may interpret backslash escapes without an option
# to disable this behavior.
puts()
{
printf "%s\n" "$1"
}
# Get the name of a trace event
get_name()
{
local name
name=${1%%\(*}
echo "${name##* }"
}
# Get the given property of a trace event
# 1: trace-events line
# 2: property name
# -> return 0 if property is present, or 1 otherwise
has_property()
{
local props prop
props=${1%%\(*}
props=${props% *}
for prop in $props; do
if [ "$prop" = "$2" ]; then
return 0
fi
done
return 1
}
# Get the argument list of a trace event, including types and names
get_args()
{
local args
args=${1#*\(}
args=${args%%\)*}
echo "$args"
if (echo "$args" | grep "[ *]next\($\|[, ]\)" > /dev/null 2>&1); then
echo -e "\n#error 'next' is a bad argument name (clash with systemtap keyword)\n "
fi
}
# 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 including double quotes for a trace event
get_fmt()
{
puts "${1#*)}"
}
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
}
linetod_nop()
{
# Used when "disabled" events are processed
return
}
linetostap_nop()
{
# Used when "disabled" events are processed
return
}
linetoc_end_nop()
{
return
}
linetoh_begin_simple()
{
cat <<EOF
#include "trace/simple.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
name=$(get_name "$1")
args=$(get_args "$1")
argc=$(get_argc "$1")
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
name=$(get_name "$1")
cat <<EOF
{.tp_name = "$name", .state=0},
EOF
simple_event_num=$((simple_event_num + 1))
}
linetoc_end_simple()
{
cat <<EOF
};
EOF
}
#STDERR
linetoh_begin_stderr()
{
cat <<EOF
#include <stdio.h>
#include "trace/stderr.h"
extern TraceEvent trace_list[];
EOF
stderr_event_num=0
}
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)
{
if (trace_list[$stderr_event_num].state != 0) {
fprintf(stderr, "$name " $fmt "\n" $argnames);
}
}
EOF
stderr_event_num=$((stderr_event_num + 1))
}
linetoh_end_stderr()
{
cat <<EOF
#define NR_TRACE_EVENTS $stderr_event_num
EOF
}
linetoc_begin_stderr()
{
cat <<EOF
#include "trace.h"
TraceEvent trace_list[] = {
EOF
stderr_event_num=0
}
linetoc_stderr()
{
local name
name=$(get_name "$1")
cat <<EOF
{.tp_name = "$name", .state=0},
EOF
stderr_event_num=$(($stderr_event_num + 1))
}
linetoc_end_stderr()
{
cat <<EOF
};
EOF
}
#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", ",")
[ -z "$argnames" ] || argnames=", $argnames"
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 nameupper
name=$(get_name "$1")
args=$(get_args "$1")
argnames=$(get_argnames "$1", ",")
nameupper=`echo $name | LC_ALL=C tr '[a-z]' '[A-Z]'`
# Define an empty function for the trace event
cat <<EOF
static inline void trace_$name($args) {
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
name=$(get_name "$1")
args=$(get_args "$1")
# 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
name=$(get_name "$1")
args=$(get_args "$1")
arglist=$(get_argnames "$1", "")
# Define prototype for probe arguments
cat <<EOF
probe $probeprefix.$name = process("$binary").mark("$name")
{
EOF
i=1
for arg in $arglist
do
# postfix reserved words with '_'
case "$arg" in
limit|in|next|self)
arg="${arg}_"
;;
esac
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 name NAME enabled
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
echo
# Process the line. The nop backend handles disabled lines.
if has_property "$str" "disable"; then
"lineto$1_nop" "$str"
enabled=0
else
"$process_line" "$str"
enabled=1
fi
if [ "$1" = "h" ]; then
name=$(get_name "$str")
NAME=$(echo $name | LC_ALL=C tr '[a-z]' '[A-Z]')
echo "#define TRACE_${NAME}_ENABLED ${enabled}"
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
scripts/tracetool.py 0 → 100755
浏览文件 @ e5e38957
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Command-line wrapper for the tracetool machinery.
"""
__author__ = "Lluís Vilanova <vilanova@ac.upc.edu>"
__copyright__ = "Copyright 2012, Lluís Vilanova <vilanova@ac.upc.edu>"
__license__ = "GPL version 2 or (at your option) any later version"
__maintainer__ = "Stefan Hajnoczi"
__email__ = "stefanha@linux.vnet.ibm.com"
import sys
import getopt
from tracetool import error_write, out
import tracetool.backend
import tracetool.format
_SCRIPT = ""
def error_opt(msg = None):
if msg is not None:
error_write("Error: " + msg + "\n")
backend_descr = "\n".join([ " %-15s %s" % (n, d)
for n,d in tracetool.backend.get_list() ])
format_descr = "\n".join([ " %-15s %s" % (n, d)
for n,d in tracetool.format.get_list() ])
error_write("""\
Usage: %(script)s --format=<format> --backend=<backend> [<options>]
Backends:
%(backends)s
Formats:
%(formats)s
Options:
--help This help message.
--list-backends Print list of available backends.
--check-backend Check if the given backend is valid.
--binary <path> Full path to QEMU binary.
--target-type <type> QEMU emulator target type ('system' or 'user').
--target-arch <arch> QEMU emulator target arch.
--probe-prefix <prefix> Prefix for dtrace probe names
(default: qemu-<target-type>-<target-arch>).\
""" % {
"script" : _SCRIPT,
"backends" : backend_descr,
"formats" : format_descr,
})
if msg is None:
sys.exit(0)
else:
sys.exit(1)
def main(args):
global _SCRIPT
_SCRIPT = args[0]
long_opts = [ "backend=", "format=", "help", "list-backends", "check-backend" ]
long_opts += [ "binary=", "target-type=", "target-arch=", "probe-prefix=" ]
try:
opts, args = getopt.getopt(args[1:], "", long_opts)
except getopt.GetoptError as err:
error_opt(str(err))
check_backend = False
arg_backend = ""
arg_format = ""
binary = None
target_type = None
target_arch = None
probe_prefix = None
for opt, arg in opts:
if opt == "--help":
error_opt()
elif opt == "--backend":
arg_backend = arg
elif opt == "--format":
arg_format = arg
elif opt == "--list-backends":
backends = tracetool.backend.get_list()
out(", ".join([ b for b,_ in backends ]))
sys.exit(0)
elif opt == "--check-backend":
check_backend = True
elif opt == "--binary":
binary = arg
elif opt == '--target-type':
target_type = arg
elif opt == '--target-arch':
target_arch = arg
elif opt == '--probe-prefix':
probe_prefix = arg
else:
error_opt("unhandled option: %s" % opt)
if arg_backend is None:
error_opt("backend not set")
if check_backend:
if tracetool.backend.exists(arg_backend):
sys.exit(0)
else:
sys.exit(1)
if arg_format == "stap":
if binary is None:
error_opt("--binary is required for SystemTAP tapset generator")
if probe_prefix is None and target_type is None:
error_opt("--target-type is required for SystemTAP tapset generator")
if probe_prefix is None and target_arch is None:
error_opt("--target-arch is required for SystemTAP tapset generator")
if probe_prefix is None:
probe_prefix = ".".join([ "qemu", target_type, target_arch ])
try:
tracetool.generate(sys.stdin, arg_format, arg_backend,
binary = binary, probe_prefix = probe_prefix)
except tracetool.TracetoolError as e:
error_opt(str(e))
if __name__ == "__main__":
main(sys.argv)
scripts/tracetool/__init__.py 0 → 100644
浏览文件 @ e5e38957
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Machinery for generating tracing-related intermediate files.
"""
__author__ = "Lluís Vilanova <vilanova@ac.upc.edu>"
__copyright__ = "Copyright 2012, Lluís Vilanova <vilanova@ac.upc.edu>"
__license__ = "GPL version 2 or (at your option) any later version"
__maintainer__ = "Stefan Hajnoczi"
__email__ = "stefanha@linux.vnet.ibm.com"
import re
import sys
import tracetool.format
import tracetool.backend
def error_write(*lines):
"""Write a set of error lines."""
sys.stderr.writelines("\n".join(lines) + "\n")
def error(*lines):
"""Write a set of error lines and exit."""
error_write(*lines)
sys.exit(1)
def out(*lines, **kwargs):
"""Write a set of output lines.
You can use kwargs as a shorthand for mapping variables when formating all
the strings in lines.
"""
lines = [ l % kwargs for l in lines ]
sys.stdout.writelines("\n".join(lines) + "\n")
class Arguments:
"""Event arguments description."""
def __init__(self, args):
"""
Parameters
----------
args :
List of (type, name) tuples.
"""
self._args = args
@staticmethod
def build(arg_str):
"""Build and Arguments instance from an argument string.
Parameters
----------
arg_str : str
String describing the event arguments.
"""
res = []
for arg in arg_str.split(","):
arg = arg.strip()
parts = arg.split()
head, sep, tail = parts[-1].rpartition("*")
parts = parts[:-1]
if tail == "void":
assert len(parts) == 0 and sep == ""
continue
arg_type = " ".join(parts + [ " ".join([head, sep]).strip() ]).strip()
res.append((arg_type, tail))
return Arguments(res)
def __iter__(self):
"""Iterate over the (type, name) pairs."""
return iter(self._args)
def __len__(self):
"""Number of arguments."""
return len(self._args)
def __str__(self):
"""String suitable for declaring function arguments."""
if len(self._args) == 0:
return "void"
else:
return ", ".join([ " ".join([t, n]) for t,n in self._args ])
def __repr__(self):
"""Evaluable string representation for this object."""
return "Arguments(\"%s\")" % str(self)
def names(self):
"""List of argument names."""
return [ name for _, name in self._args ]
def types(self):
"""List of argument types."""
return [ type_ for type_, _ in self._args ]
class Event(object):
"""Event description.
Attributes
----------
name : str
The event name.
fmt : str
The event format string.
properties : set(str)
Properties of the event.
args : Arguments
The event arguments.
"""
_CRE = re.compile("((?P<props>.*)\s+)?(?P<name>[^(\s]+)\((?P<args>[^)]*)\)\s*(?P<fmt>\".*)?")
_VALID_PROPS = set(["disable"])
def __init__(self, name, props, fmt, args):
"""
Parameters
----------
name : string
Event name.
props : list of str
Property names.
fmt : str
Event printing format.
args : Arguments
Event arguments.
"""
self.name = name
self.properties = props
self.fmt = fmt
self.args = args
unknown_props = set(self.properties) - self._VALID_PROPS
if len(unknown_props) > 0:
raise ValueError("Unknown properties: %s" % ", ".join(unknown_props))
@staticmethod
def build(line_str):
"""Build an Event instance from a string.
Parameters
----------
line_str : str
Line describing the event.
"""
m = Event._CRE.match(line_str)
assert m is not None
groups = m.groupdict('')
name = groups["name"]
props = groups["props"].split()
fmt = groups["fmt"]
args = Arguments.build(groups["args"])
return Event(name, props, fmt, args)
def __repr__(self):
"""Evaluable string representation for this object."""
return "Event('%s %s(%s) %s')" % (" ".join(self.properties),
self.name,
self.args,
self.fmt)
def _read_events(fobj):
res = []
for line in fobj:
if not line.strip():
continue
if line.lstrip().startswith('#'):
continue
res.append(Event.build(line))
return res
class TracetoolError (Exception):
"""Exception for calls to generate."""
pass
def try_import(mod_name, attr_name = None, attr_default = None):
"""Try to import a module and get an attribute from it.
Parameters
----------
mod_name : str
Module name.
attr_name : str, optional
Name of an attribute in the module.
attr_default : optional
Default value if the attribute does not exist in the module.
Returns
-------
A pair indicating whether the module could be imported and the module or
object or attribute value.
"""
try:
module = __import__(mod_name, fromlist=["__package__"])
if attr_name is None:
return True, module
return True, getattr(module, str(attr_name), attr_default)
except ImportError:
return False, None
def generate(fevents, format, backend,
binary = None, probe_prefix = None):
"""Generate the output for the given (format, backend) pair.
Parameters
----------
fevents : file
Event description file.
format : str
Output format name.
backend : str
Output backend name.
binary : str or None
See tracetool.backend.dtrace.BINARY.
probe_prefix : str or None
See tracetool.backend.dtrace.PROBEPREFIX.
"""
# fix strange python error (UnboundLocalError tracetool)
import tracetool
format = str(format)
if len(format) is 0:
raise TracetoolError("format not set")
mformat = format.replace("-", "_")
if not tracetool.format.exists(mformat):
raise TracetoolError("unknown format: %s" % format)
backend = str(backend)
if len(backend) is 0:
raise TracetoolError("backend not set")
mbackend = backend.replace("-", "_")
if not tracetool.backend.exists(mbackend):
raise TracetoolError("unknown backend: %s" % backend)
if not tracetool.backend.compatible(mbackend, mformat):
raise TracetoolError("backend '%s' not compatible with format '%s'" %
(backend, format))
import tracetool.backend.dtrace
tracetool.backend.dtrace.BINARY = binary
tracetool.backend.dtrace.PROBEPREFIX = probe_prefix
events = _read_events(fevents)
if backend == "nop":
( e.properies.add("disable") for e in events )
tracetool.format.generate_begin(mformat, events)
tracetool.backend.generate("nop", format,
[ e
for e in events
if "disable" in e.properties ])
tracetool.backend.generate(backend, format,
[ e
for e in events
if "disable" not in e.properties ])
tracetool.format.generate_end(mformat, events)
scripts/tracetool/backend/__init__.py 0 → 100644
浏览文件 @ e5e38957
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Backend management.
Creating new backends
---------------------
A new backend named 'foo-bar' corresponds to Python module
'tracetool/backend/foo_bar.py'.
A backend module should provide a docstring, whose first non-empty line will be
considered its short description.
All backends must generate their contents through the 'tracetool.out' routine.
Backend functions
-----------------
======== =======================================================================
Function Description
======== =======================================================================
<format> Called to generate the format- and backend-specific code for each of
the specified events. If the function does not exist, the backend is
considered not compatible with the given format.
======== =======================================================================
"""
__author__ = "Lluís Vilanova <vilanova@ac.upc.edu>"
__copyright__ = "Copyright 2012, Lluís Vilanova <vilanova@ac.upc.edu>"
__license__ = "GPL version 2 or (at your option) any later version"
__maintainer__ = "Stefan Hajnoczi"
__email__ = "stefanha@linux.vnet.ibm.com"
import pkgutil
import tracetool
def get_list():
"""Get a list of (name, description) pairs."""
res = [("nop", "Tracing disabled.")]
for _, modname, _ in pkgutil.iter_modules(tracetool.backend.__path__):
module = tracetool.try_import("tracetool.backend." + modname)
# just in case; should never fail unless non-module files are put there
if not module[0]:
continue
module = module[1]
doc = module.__doc__
if doc is None:
doc = ""
doc = doc.strip().split("\n")[0]
name = modname.replace("_", "-")
res.append((name, doc))
return res
def exists(name):
"""Return whether the given backend exists."""
if len(name) == 0:
return False
if name == "nop":
return True
name = name.replace("-", "_")
return tracetool.try_import("tracetool.backend." + name)[1]
def compatible(backend, format):
"""Whether a backend is compatible with the given format."""
if not exists(backend):
raise ValueError("unknown backend: %s" % backend)
backend = backend.replace("-", "_")
format = format.replace("-", "_")
if backend == "nop":
return True
else:
func = tracetool.try_import("tracetool.backend." + backend,
format, None)[1]
return func is not None
def _empty(events):
pass
def generate(backend, format, events):
"""Generate the per-event output for the given (backend, format) pair."""
if not compatible(backend, format):
raise ValueError("backend '%s' not compatible with format '%s'" %
(backend, format))
backend = backend.replace("-", "_")
format = format.replace("-", "_")
if backend == "nop":
func = tracetool.try_import("tracetool.format." + format,
"nop", _empty)[1]
else:
func = tracetool.try_import("tracetool.backend." + backend,
format, None)[1]
func(events)
scripts/tracetool/backend/dtrace.py 0 → 100644
浏览文件 @ e5e38957
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
DTrace/SystemTAP backend.
"""
__author__ = "Lluís Vilanova <vilanova@ac.upc.edu>"
__copyright__ = "Copyright 2012, Lluís Vilanova <vilanova@ac.upc.edu>"
__license__ = "GPL version 2 or (at your option) any later version"
__maintainer__ = "Stefan Hajnoczi"
__email__ = "stefanha@linux.vnet.ibm.com"
from tracetool import out
PROBEPREFIX = None
def _probeprefix():
if PROBEPREFIX is None:
raise ValueError("you must set PROBEPREFIX")
return PROBEPREFIX
BINARY = None
def _binary():
if BINARY is None:
raise ValueError("you must set BINARY")
return BINARY
def c(events):
pass
def h(events):
out('#include "trace-dtrace.h"',
'')
for e in events:
out('static inline void trace_%(name)s(%(args)s) {',
' QEMU_%(uppername)s(%(argnames)s);',
'}',
name = e.name,
args = e.args,
uppername = e.name.upper(),
argnames = ", ".join(e.args.names()),
)
def d(events):
out('provider qemu {')
for e in events:
args = str(e.args)
# DTrace provider syntax expects foo() for empty
# params, not foo(void)
if args == 'void':
args = ''
# Define prototype for probe arguments
out('',
'probe %(name)s(%(args)s);',
name = e.name,
args = args,
)
out('',
'};')
def stap(events):
for e in events:
# Define prototype for probe arguments
out('probe %(probeprefix)s.%(name)s = process("%(binary)s").mark("%(name)s")',
'{',
probeprefix = _probeprefix(),
name = e.name,
binary = _binary(),
)
i = 1
if len(e.args) > 0:
for name in e.args.names():
# Append underscore to reserved keywords
if name in ('limit', 'in', 'next', 'self'):
name += '_'
out(' %s = $arg%d;' % (name, i))
i += 1
out('}')
out()
scripts/tracetool/backend/simple.py 0 → 100644
浏览文件 @ e5e38957
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Simple built-in backend.
"""
__author__ = "Lluís Vilanova <vilanova@ac.upc.edu>"
__copyright__ = "Copyright 2012, Lluís Vilanova <vilanova@ac.upc.edu>"
__license__ = "GPL version 2 or (at your option) any later version"
__maintainer__ = "Stefan Hajnoczi"
__email__ = "stefanha@linux.vnet.ibm.com"
from tracetool import out
def c(events):
out('#include "trace.h"',
'',
'TraceEvent trace_list[] = {')
for e in events:
out('{.tp_name = "%(name)s", .state=0},',
name = e.name,
)
out('};')
def h(events):
out('#include "trace/simple.h"',
'')
for num, e in enumerate(events):
if len(e.args):
argstr = e.args.names()
arg_prefix = ', (uint64_t)(uintptr_t)'
cast_args = arg_prefix + arg_prefix.join(argstr)
simple_args = (str(num) + cast_args)
else:
simple_args = str(num)
out('static inline void trace_%(name)s(%(args)s)',
'{',
' trace%(argc)d(%(trace_args)s);',
'}',
name = e.name,
args = e.args,
argc = len(e.args),
trace_args = simple_args,
)
out('#define NR_TRACE_EVENTS %d' % len(events))
out('extern TraceEvent trace_list[NR_TRACE_EVENTS];')
scripts/tracetool/backend/stderr.py 0 → 100644
浏览文件 @ e5e38957
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Stderr built-in backend.
"""
__author__ = "Lluís Vilanova <vilanova@ac.upc.edu>"
__copyright__ = "Copyright 2012, Lluís Vilanova <vilanova@ac.upc.edu>"
__license__ = "GPL version 2 or (at your option) any later version"
__maintainer__ = "Stefan Hajnoczi"
__email__ = "stefanha@linux.vnet.ibm.com"
from tracetool import out
def c(events):
out('#include "trace.h"',
'',
'TraceEvent trace_list[] = {')
for e in events:
out('{.tp_name = "%(name)s", .state=0},',
name = e.name,
)
out('};')
def h(events):
out('#include <stdio.h>',
'#include "trace/stderr.h"',
'',
'extern TraceEvent trace_list[];')
for num, e in enumerate(events):
argnames = ", ".join(e.args.names())
if len(e.args) > 0:
argnames = ", " + argnames
out('static inline void trace_%(name)s(%(args)s)',
'{',
' if (trace_list[%(event_num)s].state != 0) {',
' fprintf(stderr, "%(name)s " %(fmt)s "\\n" %(argnames)s);',
' }',
'}',
name = e.name,
args = e.args,
event_num = num,
fmt = e.fmt,
argnames = argnames,
)
out('',
'#define NR_TRACE_EVENTS %d' % len(events))
scripts/tracetool/backend/ust.py 0 → 100644
浏览文件 @ e5e38957
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
LTTng User Space Tracing backend.
"""
__author__ = "Lluís Vilanova <vilanova@ac.upc.edu>"
__copyright__ = "Copyright 2012, Lluís Vilanova <vilanova@ac.upc.edu>"
__license__ = "GPL version 2 or (at your option) any later version"
__maintainer__ = "Stefan Hajnoczi"
__email__ = "stefanha@linux.vnet.ibm.com"
from tracetool import out
def c(events):
out('#include <ust/marker.h>',
'#undef mutex_lock',
'#undef mutex_unlock',
'#undef inline',
'#undef wmb',
'#include "trace.h"')
for e in events:
argnames = ", ".join(e.args.names())
if len(e.args) > 0:
argnames = ', ' + argnames
out('DEFINE_TRACE(ust_%(name)s);',
'',
'static void ust_%(name)s_probe(%(args)s)',
'{',
' trace_mark(ust, %(name)s, %(fmt)s%(argnames)s);',
'}',
name = e.name,
args = e.args,
fmt = e.fmt,
argnames = argnames,
)
else:
out('DEFINE_TRACE(ust_%(name)s);',
'',
'static void ust_%(name)s_probe(%(args)s)',
'{',
' trace_mark(ust, %(name)s, UST_MARKER_NOARGS);',
'}',
name = e.name,
args = e.args,
)
# register probes
out('',
'static void __attribute__((constructor)) trace_init(void)',
'{')
for e in events:
out(' register_trace_ust_%(name)s(ust_%(name)s_probe);',
name = e.name,
)
out('}')
def h(events):
out('#include <ust/tracepoint.h>',
'#undef mutex_lock',
'#undef mutex_unlock',
'#undef inline',
'#undef wmb')
for e in events:
if len(e.args) > 0:
out('DECLARE_TRACE(ust_%(name)s, TP_PROTO(%(args)s), TP_ARGS(%(argnames)s));',
'#define trace_%(name)s trace_ust_%(name)s',
name = e.name,
args = e.args,
argnames = ", ".join(e.args.names()),
)
else:
out('_DECLARE_TRACEPOINT_NOARGS(ust_%(name)s);',
'#define trace_%(name)s trace_ust_%(name)s',
name = e.name,
)
out()
scripts/tracetool/format/__init__.py 0 → 100644
浏览文件 @ e5e38957
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Format management.
Creating new formats
--------------------
A new format named 'foo-bar' corresponds to Python module
'tracetool/format/foo_bar.py'.
A format module should provide a docstring, whose first non-empty line will be
considered its short description.
All formats must generate their contents through the 'tracetool.out' routine.
Format functions
----------------
All the following functions are optional, and no output will be generated if
they do not exist.
======== =======================================================================
Function Description
======== =======================================================================
begin Called to generate the format-specific file header.
end Called to generate the format-specific file footer.
nop Called to generate the per-event contents when the event is disabled or
the selected backend is 'nop'.
======== =======================================================================
"""
__author__ = "Lluís Vilanova <vilanova@ac.upc.edu>"
__copyright__ = "Copyright 2012, Lluís Vilanova <vilanova@ac.upc.edu>"
__license__ = "GPL version 2 or (at your option) any later version"
__maintainer__ = "Stefan Hajnoczi"
__email__ = "stefanha@linux.vnet.ibm.com"
import pkgutil
import tracetool
def get_list():
"""Get a list of (name, description) pairs."""
res = []
for _, modname, _ in pkgutil.iter_modules(tracetool.format.__path__):
module = tracetool.try_import("tracetool.format." + modname)
# just in case; should never fail unless non-module files are put there
if not module[0]:
continue
module = module[1]
doc = module.__doc__
if doc is None:
doc = ""
doc = doc.strip().split("\n")[0]
name = modname.replace("_", "-")
res.append((name, doc))
return res
def exists(name):
"""Return whether the given format exists."""
if len(name) == 0:
return False
name = name.replace("-", "_")
return tracetool.try_import("tracetool.format." + name)[1]
def _empty(events):
pass
def generate_begin(name, events):
"""Generate the header of the format-specific file."""
if not exists(name):
raise ValueError("unknown format: %s" % name)
name = name.replace("-", "_")
func = tracetool.try_import("tracetool.format." + name,
"begin", _empty)[1]
func(events)
def generate_end(name, events):
"""Generate the footer of the format-specific file."""
if not exists(name):
raise ValueError("unknown format: %s" % name)
name = name.replace("-", "_")
func = tracetool.try_import("tracetool.format." + name,
"end", _empty)[1]
func(events)
scripts/tracetool/format/c.py 0 → 100644
浏览文件 @ e5e38957
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Generate .c file.
"""
__author__ = "Lluís Vilanova <vilanova@ac.upc.edu>"
__copyright__ = "Copyright 2012, Lluís Vilanova <vilanova@ac.upc.edu>"
__license__ = "GPL version 2 or (at your option) any later version"
__maintainer__ = "Stefan Hajnoczi"
__email__ = "stefanha@linux.vnet.ibm.com"
from tracetool import out
def begin(events):
out('/* This file is autogenerated by tracetool, do not edit. */')
scripts/tracetool/format/d.py 0 → 100644
浏览文件 @ e5e38957
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Generate .d file (DTrace only).
"""
__author__ = "Lluís Vilanova <vilanova@ac.upc.edu>"
__copyright__ = "Copyright 2012, Lluís Vilanova <vilanova@ac.upc.edu>"
__license__ = "GPL version 2 or (at your option) any later version"
__maintainer__ = "Stefan Hajnoczi"
__email__ = "stefanha@linux.vnet.ibm.com"
from tracetool import out
def begin(events):
out('/* This file is autogenerated by tracetool, do not edit. */')
scripts/tracetool/format/h.py 0 → 100644
浏览文件 @ e5e38957
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Generate .h file.
"""
__author__ = "Lluís Vilanova <vilanova@ac.upc.edu>"
__copyright__ = "Copyright 2012, Lluís Vilanova <vilanova@ac.upc.edu>"
__license__ = "GPL version 2 or (at your option) any later version"
__maintainer__ = "Stefan Hajnoczi"
__email__ = "stefanha@linux.vnet.ibm.com"
from tracetool import out
def begin(events):
out('/* This file is autogenerated by tracetool, do not edit. */',
'',
'#ifndef TRACE_H',
'#define TRACE_H',
'',
'#include "qemu-common.h"')
def end(events):
for e in events:
if "disable" in e.properties:
enabled = 0
else:
enabled = 1
out('#define TRACE_%s_ENABLED %d' % (e.name.upper(), enabled))
out('',
'#endif /* TRACE_H */')
def nop(events):
for e in events:
out('',
'static inline void trace_%(name)s(%(args)s)',
'{',
'}',
name = e.name,
args = e.args,
)
scripts/tracetool/format/stap.py 0 → 100644
浏览文件 @ e5e38957
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Generate .stp file (DTrace with SystemTAP only).
"""
__author__ = "Lluís Vilanova <vilanova@ac.upc.edu>"
__copyright__ = "Copyright 2012, Lluís Vilanova <vilanova@ac.upc.edu>"
__license__ = "GPL version 2 or (at your option) any later version"
__maintainer__ = "Stefan Hajnoczi"
__email__ = "stefanha@linux.vnet.ibm.com"
from tracetool import out
def begin(events):
out('/* This file is autogenerated by tracetool, do not edit. */')
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或