mirror of
https://github.com/percona/percona-toolkit.git
synced 2025-09-05 20:07:54 +00:00
1075 lines
30 KiB
Bash
Executable File
1075 lines
30 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
|
|
# This program is part of Percona Toolkit: http://www.percona.com/software/
|
|
# See "COPYRIGHT, LICENSE, AND WARRANTY" at the end of this file for legal
|
|
# notices and disclaimers.
|
|
|
|
# ###########################################################################
|
|
# log_warn_die package
|
|
# This package is a copy without comments from the original. The original
|
|
# with comments and its test file can be found in the Bazaar repository at,
|
|
# lib/bash/log_warn_die.sh
|
|
# t/lib/bash/log_warn_die.sh
|
|
# See https://launchpad.net/percona-toolkit for more information.
|
|
# ###########################################################################
|
|
|
|
|
|
set -u
|
|
|
|
PTFUNCNAME=""
|
|
PTDEBUG="${PTDEBUG:-""}"
|
|
EXIT_STATUS=0
|
|
|
|
log() {
|
|
TS=$(date +%F-%T | tr :- _);
|
|
echo "$TS $*"
|
|
}
|
|
|
|
warn() {
|
|
log "$*" >&2
|
|
EXIT_STATUS=1
|
|
}
|
|
|
|
die() {
|
|
warn "$*"
|
|
exit 1
|
|
}
|
|
|
|
_d () {
|
|
[ "$PTDEBUG" ] && echo "# $PTFUNCNAME: $(log "$*")" >&2
|
|
}
|
|
|
|
# ###########################################################################
|
|
# End log_warn_die package
|
|
# ###########################################################################
|
|
|
|
# ###########################################################################
|
|
# parse_options package
|
|
# This package is a copy without comments from the original. The original
|
|
# with comments and its test file can be found in the Bazaar repository at,
|
|
# lib/bash/parse_options.sh
|
|
# t/lib/bash/parse_options.sh
|
|
# See https://launchpad.net/percona-toolkit for more information.
|
|
# ###########################################################################
|
|
|
|
|
|
|
|
|
|
|
|
set -u
|
|
|
|
ARGV="" # Non-option args (probably input files)
|
|
EXT_ARGV="" # Everything after -- (args for an external command)
|
|
HAVE_EXT_ARGV="" # Got --, everything else is put into EXT_ARGV
|
|
OPT_ERRS=0 # How many command line option errors
|
|
OPT_VERSION="" # If --version was specified
|
|
OPT_HELP="" # If --help was specified
|
|
PO_DIR="" # Directory with program option spec files
|
|
|
|
usage() {
|
|
local file="$1"
|
|
|
|
local usage=$(grep '^Usage: ' "$file")
|
|
echo $usage
|
|
echo
|
|
echo "For more information, 'man $TOOL' or 'perldoc $file'."
|
|
}
|
|
|
|
usage_or_errors() {
|
|
local file="$1"
|
|
|
|
if [ "$OPT_VERSION" ]; then
|
|
local version=$(grep '^pt-[^ ]\+ [0-9]' "$file")
|
|
echo "$version"
|
|
return 1
|
|
fi
|
|
|
|
if [ "$OPT_HELP" ]; then
|
|
usage "$file"
|
|
echo
|
|
echo "Command line options:"
|
|
echo
|
|
perl -e '
|
|
use strict;
|
|
use warnings FATAL => qw(all);
|
|
my $lcol = 20; # Allow this much space for option names.
|
|
my $rcol = 80 - $lcol; # The terminal is assumed to be 80 chars wide.
|
|
my $name;
|
|
while ( <> ) {
|
|
my $line = $_;
|
|
chomp $line;
|
|
if ( $line =~ s/^long:/ --/ ) {
|
|
$name = $line;
|
|
}
|
|
elsif ( $line =~ s/^desc:// ) {
|
|
$line =~ s/ +$//mg;
|
|
my @lines = grep { $_ }
|
|
$line =~ m/(.{0,$rcol})(?:\s+|\Z)/g;
|
|
if ( length($name) >= $lcol ) {
|
|
print $name, "\n", (q{ } x $lcol);
|
|
}
|
|
else {
|
|
printf "%-${lcol}s", $name;
|
|
}
|
|
print join("\n" . (q{ } x $lcol), @lines);
|
|
print "\n";
|
|
}
|
|
}
|
|
' "$PO_DIR"/*
|
|
echo
|
|
echo "Options and values after processing arguments:"
|
|
echo
|
|
for opt in $(ls "$PO_DIR"); do
|
|
local varname="OPT_$(echo "$opt" | tr a-z- A-Z_)"
|
|
local varvalue="${!varname}"
|
|
printf -- " --%-30s %s" "$opt" "${varvalue:-(No value)}"
|
|
echo
|
|
done
|
|
return 1
|
|
fi
|
|
|
|
if [ $OPT_ERRS -gt 0 ]; then
|
|
echo
|
|
usage "$file"
|
|
return 1
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
option_error() {
|
|
local err="$1"
|
|
OPT_ERRS=$(($OPT_ERRS + 1))
|
|
echo "$err" >&2
|
|
}
|
|
|
|
parse_options() {
|
|
local file="$1"
|
|
shift
|
|
|
|
ARGV=""
|
|
EXT_ARGV=""
|
|
HAVE_EXT_ARGV=""
|
|
OPT_ERRS=0
|
|
OPT_VERSION=""
|
|
OPT_HELP=""
|
|
PO_DIR="$TMPDIR/po"
|
|
|
|
if [ ! -d "$PO_DIR" ]; then
|
|
mkdir "$PO_DIR"
|
|
if [ $? -ne 0 ]; then
|
|
echo "Cannot mkdir $PO_DIR" >&2
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
rm -rf "$PO_DIR"/*
|
|
if [ $? -ne 0 ]; then
|
|
echo "Cannot rm -rf $PO_DIR/*" >&2
|
|
exit 1
|
|
fi
|
|
|
|
_parse_pod "$file" # Parse POD into program option (po) spec files
|
|
_eval_po # Eval po into existence with default values
|
|
|
|
if [ $# -ge 2 ] && [ "$1" = "--config" ]; then
|
|
shift # --config
|
|
local user_config_files="$1"
|
|
shift # that ^
|
|
local IFS=","
|
|
for user_config_file in $user_config_files; do
|
|
_parse_config_files "$user_config_file"
|
|
done
|
|
else
|
|
_parse_config_files "/etc/percona-toolkit/percona-toolkit.conf" "/etc/percona-toolkit/$TOOL.conf" "$HOME/.percona-toolkit.conf" "$HOME/.$TOOL.conf"
|
|
fi
|
|
|
|
_parse_command_line "$@"
|
|
}
|
|
|
|
_parse_pod() {
|
|
local file="$1"
|
|
|
|
cat "$file" | PO_DIR="$PO_DIR" perl -ne '
|
|
BEGIN { $/ = ""; }
|
|
next unless $_ =~ m/^=head1 OPTIONS/;
|
|
while ( defined(my $para = <>) ) {
|
|
last if $para =~ m/^=head1/;
|
|
chomp;
|
|
if ( $para =~ m/^=item --(\S+)/ ) {
|
|
my $opt = $1;
|
|
my $file = "$ENV{PO_DIR}/$opt";
|
|
open my $opt_fh, ">", $file or die "Cannot open $file: $!";
|
|
print $opt_fh "long:$opt\n";
|
|
$para = <>;
|
|
chomp;
|
|
if ( $para =~ m/^[a-z ]+:/ ) {
|
|
map {
|
|
chomp;
|
|
my ($attrib, $val) = split(/: /, $_);
|
|
print $opt_fh "$attrib:$val\n";
|
|
} split(/; /, $para);
|
|
$para = <>;
|
|
chomp;
|
|
}
|
|
my ($desc) = $para =~ m/^([^?.]+)/;
|
|
print $opt_fh "desc:$desc.\n";
|
|
close $opt_fh;
|
|
}
|
|
}
|
|
last;
|
|
'
|
|
}
|
|
|
|
_eval_po() {
|
|
local IFS=":"
|
|
for opt_spec in "$PO_DIR"/*; do
|
|
local opt=""
|
|
local default_val=""
|
|
local neg=0
|
|
local size=0
|
|
while read key val; do
|
|
case "$key" in
|
|
long)
|
|
opt=$(echo $val | sed 's/-/_/g' | tr [:lower:] [:upper:])
|
|
;;
|
|
default)
|
|
default_val="$val"
|
|
;;
|
|
"short form")
|
|
;;
|
|
type)
|
|
[ "$val" = "size" ] && size=1
|
|
;;
|
|
desc)
|
|
;;
|
|
negatable)
|
|
if [ "$val" = "yes" ]; then
|
|
neg=1
|
|
fi
|
|
;;
|
|
*)
|
|
echo "Invalid attribute in $opt_spec: $line" >&2
|
|
exit 1
|
|
esac
|
|
done < "$opt_spec"
|
|
|
|
if [ -z "$opt" ]; then
|
|
echo "No long attribute in option spec $opt_spec" >&2
|
|
exit 1
|
|
fi
|
|
|
|
if [ $neg -eq 1 ]; then
|
|
if [ -z "$default_val" ] || [ "$default_val" != "yes" ]; then
|
|
echo "Option $opt_spec is negatable but not default: yes" >&2
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
if [ $size -eq 1 -a -n "$default_val" ]; then
|
|
default_val=$(size_to_bytes $default_val)
|
|
fi
|
|
|
|
eval "OPT_${opt}"="$default_val"
|
|
done
|
|
}
|
|
|
|
_parse_config_files() {
|
|
|
|
for config_file in "$@"; do
|
|
test -f "$config_file" || continue
|
|
|
|
while read config_opt; do
|
|
|
|
echo "$config_opt" | grep '^[ ]*[^#]' >/dev/null 2>&1 || continue
|
|
|
|
config_opt="$(echo "$config_opt" | sed -e 's/^ *//g' -e 's/ *$//g' -e 's/[ ]*=[ ]*/=/' -e 's/[ ]*#.*$//')"
|
|
|
|
[ "$config_opt" = "" ] && continue
|
|
|
|
if ! [ "$HAVE_EXT_ARGV" ]; then
|
|
config_opt="--$config_opt"
|
|
fi
|
|
|
|
_parse_command_line "$config_opt"
|
|
|
|
done < "$config_file"
|
|
|
|
HAVE_EXT_ARGV="" # reset for each file
|
|
|
|
done
|
|
}
|
|
|
|
_parse_command_line() {
|
|
local opt=""
|
|
local val=""
|
|
local next_opt_is_val=""
|
|
local opt_is_ok=""
|
|
local opt_is_negated=""
|
|
local real_opt=""
|
|
local required_arg=""
|
|
local spec=""
|
|
|
|
for opt in "$@"; do
|
|
if [ "$opt" = "--" -o "$opt" = "----" ]; then
|
|
HAVE_EXT_ARGV=1
|
|
continue
|
|
fi
|
|
if [ "$HAVE_EXT_ARGV" ]; then
|
|
if [ "$EXT_ARGV" ]; then
|
|
EXT_ARGV="$EXT_ARGV $opt"
|
|
else
|
|
EXT_ARGV="$opt"
|
|
fi
|
|
continue
|
|
fi
|
|
|
|
if [ "$next_opt_is_val" ]; then
|
|
next_opt_is_val=""
|
|
if [ $# -eq 0 ] || [ $(expr "$opt" : "-") -eq 1 ]; then
|
|
option_error "$real_opt requires a $required_arg argument"
|
|
continue
|
|
fi
|
|
val="$opt"
|
|
opt_is_ok=1
|
|
else
|
|
if [ $(expr "$opt" : "-") -eq 0 ]; then
|
|
if [ -z "$ARGV" ]; then
|
|
ARGV="$opt"
|
|
else
|
|
ARGV="$ARGV $opt"
|
|
fi
|
|
continue
|
|
fi
|
|
|
|
real_opt="$opt"
|
|
|
|
if $(echo $opt | grep '^--no-' >/dev/null); then
|
|
opt_is_negated=1
|
|
opt=$(echo $opt | sed 's/^--no-//')
|
|
else
|
|
opt_is_negated=""
|
|
opt=$(echo $opt | sed 's/^-*//')
|
|
fi
|
|
|
|
if $(echo $opt | grep '^[a-z-][a-z-]*=' >/dev/null 2>&1); then
|
|
val="$(echo $opt | awk -F= '{print $2}')"
|
|
opt="$(echo $opt | awk -F= '{print $1}')"
|
|
fi
|
|
|
|
if [ -f "$TMPDIR/po/$opt" ]; then
|
|
spec="$TMPDIR/po/$opt"
|
|
else
|
|
spec=$(grep "^short form:-$opt\$" "$TMPDIR"/po/* | cut -d ':' -f 1)
|
|
if [ -z "$spec" ]; then
|
|
option_error "Unknown option: $real_opt"
|
|
continue
|
|
fi
|
|
fi
|
|
|
|
required_arg=$(cat "$spec" | awk -F: '/^type:/{print $2}')
|
|
if [ "$required_arg" ]; then
|
|
if [ "$val" ]; then
|
|
opt_is_ok=1
|
|
else
|
|
next_opt_is_val=1
|
|
fi
|
|
else
|
|
if [ "$val" ]; then
|
|
option_error "Option $real_opt does not take a value"
|
|
continue
|
|
fi
|
|
if [ "$opt_is_negated" ]; then
|
|
val=""
|
|
else
|
|
val="yes"
|
|
fi
|
|
opt_is_ok=1
|
|
fi
|
|
fi
|
|
|
|
if [ "$opt_is_ok" ]; then
|
|
opt=$(cat "$spec" | grep '^long:' | cut -d':' -f2 | sed 's/-/_/g' | tr [:lower:] [:upper:])
|
|
|
|
if grep "^type:size" "$spec" >/dev/null; then
|
|
val=$(size_to_bytes $val)
|
|
fi
|
|
|
|
eval "OPT_$opt"="'$val'"
|
|
|
|
opt=""
|
|
val=""
|
|
next_opt_is_val=""
|
|
opt_is_ok=""
|
|
opt_is_negated=""
|
|
real_opt=""
|
|
required_arg=""
|
|
spec=""
|
|
fi
|
|
done
|
|
}
|
|
|
|
size_to_bytes() {
|
|
local size="$1"
|
|
echo $size | perl -ne '%f=(B=>1, K=>1_024, M=>1_048_576, G=>1_073_741_824, T=>1_099_511_627_776); m/^(\d+)([kMGT])?/i; print $1 * $f{uc($2 || "B")};'
|
|
}
|
|
|
|
# ###########################################################################
|
|
# End parse_options package
|
|
# ###########################################################################
|
|
|
|
# ###########################################################################
|
|
# tmpdir package
|
|
# This package is a copy without comments from the original. The original
|
|
# with comments and its test file can be found in the Bazaar repository at,
|
|
# lib/bash/tmpdir.sh
|
|
# t/lib/bash/tmpdir.sh
|
|
# See https://launchpad.net/percona-toolkit for more information.
|
|
# ###########################################################################
|
|
|
|
|
|
set -u
|
|
|
|
TMPDIR=""
|
|
|
|
mk_tmpdir() {
|
|
local dir="${1:-""}"
|
|
|
|
if [ -n "$dir" ]; then
|
|
if [ ! -d "$dir" ]; then
|
|
mkdir "$dir" || die "Cannot make tmpdir $dir"
|
|
fi
|
|
TMPDIR="$dir"
|
|
else
|
|
local tool="${0##*/}"
|
|
local pid="$$"
|
|
local x="$TMPDIR"
|
|
TMPDIR=`TMPDIR="$x" mktemp -d -t "${tool}.${pid}.XXXXXX"` \
|
|
|| die "Cannot make secure tmpdir"
|
|
fi
|
|
}
|
|
|
|
rm_tmpdir() {
|
|
if [ -n "$TMPDIR" ] && [ -d "$TMPDIR" ]; then
|
|
rm -rf "$TMPDIR"
|
|
fi
|
|
TMPDIR=""
|
|
}
|
|
|
|
# ###########################################################################
|
|
# End tmpdir package
|
|
# ###########################################################################
|
|
|
|
# ###########################################################################
|
|
# alt_cmds package
|
|
# This package is a copy without comments from the original. The original
|
|
# with comments and its test file can be found in the Bazaar repository at,
|
|
# lib/bash/alt_cmds.sh
|
|
# t/lib/bash/alt_cmds.sh
|
|
# See https://launchpad.net/percona-toolkit for more information.
|
|
# ###########################################################################
|
|
|
|
|
|
set -u
|
|
|
|
_seq() {
|
|
local i="$1"
|
|
awk "BEGIN { for(i=1; i<=$i; i++) print i; }"
|
|
}
|
|
|
|
_pidof() {
|
|
local cmd="$1"
|
|
if ! pidof "$cmd" 2>/dev/null; then
|
|
ps -eo pid,ucomm | awk -v comm="$cmd" '$2 == comm { print $1 }'
|
|
fi
|
|
}
|
|
|
|
_lsof() {
|
|
local pid="$1"
|
|
if ! lsof -p $pid 2>/dev/null; then
|
|
/bin/ls -l /proc/$pid/fd 2>/dev/null
|
|
fi
|
|
}
|
|
|
|
|
|
|
|
_which() {
|
|
if [ -x /usr/bin/which ]; then
|
|
/usr/bin/which "$1" 2>/dev/null | awk '{print $1}'
|
|
elif which which 1>/dev/null 2>&1; then
|
|
which "$1" 2>/dev/null | awk '{print $1}'
|
|
else
|
|
echo "$1"
|
|
fi
|
|
}
|
|
|
|
# ###########################################################################
|
|
# End alt_cmds package
|
|
# ###########################################################################
|
|
|
|
# ###########################################################################
|
|
# Global variables
|
|
# ###########################################################################
|
|
TOOL="pt-ioprofile"
|
|
|
|
# ###########################################################################
|
|
# Subroutines
|
|
# ###########################################################################
|
|
|
|
# Read the 'lsof' and 'strace' from the file, and convert it into lines:
|
|
# pid function fd_no size timing filename
|
|
# The arguments are the files to summarize.
|
|
tabulate_strace() {
|
|
cat > $TMPDIR/tabulate_strace.awk <<EOF
|
|
BEGIN {
|
|
# These are function names, or partial function names, that we care about.
|
|
# Later we will ignore any function whose name doesn't look like these.
|
|
# Keep this in sync with wanted_pat in summarize_strace, too.
|
|
wanted_pat = "read|write|sync|open|close|getdents|seek|fcntl|ftrunc";
|
|
cwd = ""; # The process's cwd to prepend to ./ filenames later.
|
|
mode = 0; # Whether we're in the lsof or strace part of the input.
|
|
}
|
|
/^COMMAND/ { mode = "lsof"; }
|
|
/^Process/ { mode = "strace"; }
|
|
{
|
|
# Save the file descriptor and name for lookup later.
|
|
if ( mode == "lsof" ) {
|
|
if ( \$5 == "REG" ) {
|
|
fd = \$4;
|
|
gsub(/[rwu-].*/, "", fd);
|
|
filename_for[fd] = \$9;
|
|
}
|
|
else if ( \$5 == "DIR" && \$4 == "cwd" ) {
|
|
cwd = \$NF;
|
|
}
|
|
}
|
|
else if ( mode == "strace" && \$1 ~ /^\[/ ) {
|
|
pid = substr(\$2, 1, length(\$2) - 1);
|
|
|
|
# Continuation of a previously <unfinished ...> function call
|
|
if ( \$3 == "<..." ) {
|
|
funcn = \$4;
|
|
fd = unfinished[pid "," funcn];
|
|
if ( fd > 0 ) {
|
|
filename = filename_for[fd];
|
|
if ( filename != "" ) {
|
|
if ( funcn ~ /open/ ) {
|
|
size = 0;
|
|
}
|
|
else {
|
|
size_field = NF - 1;
|
|
size = \$size_field;
|
|
}
|
|
timing = \$NF;
|
|
gsub(/[<>]/, "", timing);
|
|
print pid, funcn, fd, size, timing, filename;
|
|
}
|
|
}
|
|
}
|
|
|
|
# The beginning of a function call (not resumed). There are basically
|
|
# two cases here: the whole call is on one line, and it's unfinished
|
|
# and ends on a later line.
|
|
else {
|
|
funcn = substr(\$3, 1, index(\$3, "(") - 1);
|
|
if ( funcn ~ wanted_pat ) {
|
|
# Save the file descriptor and name for lookup later.
|
|
if ( funcn ~ /open/ ) {
|
|
filename = substr(\$3, index(\$3, "(") + 2);
|
|
filename = substr(filename, 1, index(filename, "\\"") - 1);
|
|
if ( "./" == substr(filename, 1, 2) ) {
|
|
# Translate relative filenames into absolute ones.
|
|
filename = cwd substr(filename, 2);
|
|
}
|
|
fd_field = NF - 1;
|
|
fd = \$fd_field;
|
|
filename_for[fd] = filename;
|
|
}
|
|
|
|
else {
|
|
fd = substr(\$3, index(\$3, "(") + 1);
|
|
gsub(/[^0-9].*/, "", fd);
|
|
}
|
|
|
|
# Save unfinished calls for later
|
|
if ( \$NF == "...>" ) {
|
|
unfinished[pid "," funcn] = fd;
|
|
}
|
|
|
|
# Function calls that are all on one line, not <unfinished ...>
|
|
else {
|
|
filename = filename_for[fd];
|
|
if ( filename != "" ) {
|
|
if ( funcn ~ /open/ ) {
|
|
size = 0;
|
|
}
|
|
else {
|
|
size_field = NF - 1;
|
|
size = \$size_field;
|
|
}
|
|
timing = \$NF;
|
|
gsub(/[<>]/, "", timing);
|
|
print pid, funcn, fd, size, timing, filename;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
EOF
|
|
awk -f $TMPDIR/tabulate_strace.awk "$@"
|
|
}
|
|
|
|
# Takes as input the output from tabulate_strace. Arguments are just a subset
|
|
# of the overall command-line options, but no validation is needed. The last
|
|
# command-line option is the filename of the tabulate_strace output.
|
|
summarize_strace() {
|
|
local func="$1"
|
|
local cell="$2"
|
|
local group_by="$3"
|
|
local file="$4"
|
|
|
|
cat > "$TMPDIR/summarize_strace.awk" <<EOF
|
|
BEGIN {
|
|
# These are function names, or partial function names, that we care about.
|
|
# Later we will ignore any function whose name doesn't look like these.
|
|
# Keep this in sync with wanted_pat in tabulate_strace, too.
|
|
wanted_pat = "read|write|sync|open|close|getdents|seek|fcntl|ftrunc";
|
|
wanted["1"] = "read"; # Will match pread, pread64, etc.
|
|
wanted["2"] = "write";
|
|
wanted["3"] = "sync";
|
|
wanted["4"] = "open";
|
|
wanted["5"] = "close";
|
|
wanted["6"] = "getdents";
|
|
wanted["7"] = "seek";
|
|
wanted["8"] = "fcntl";
|
|
wanted["9"] = "ftrunc";
|
|
num_wanted = 9;
|
|
col_pat = "%10d ";
|
|
hdr_pat = "%10s ";
|
|
if ( "$cell" == "times" ) {
|
|
col_pat = "%10.6f ";
|
|
}
|
|
}
|
|
{
|
|
pid = \$1;
|
|
funcn = \$2;
|
|
fd = \$3;
|
|
size = \$4;
|
|
timing = \$5;
|
|
filename = \$6;
|
|
all = "all";
|
|
if ( funcn ~ wanted_pat ) {
|
|
func_names[funcn]++;
|
|
groupby[$group_by]++;
|
|
count[funcn "," $group_by]++;
|
|
sizes[funcn "," $group_by] += size;
|
|
times[funcn "," $group_by] += timing;
|
|
}
|
|
}
|
|
END {
|
|
# Choose which functions we want to print out, ordered by wanted[].
|
|
num_functions = 0;
|
|
if ( "$group_by" != "all" ) {
|
|
printf(hdr_pat, "total");
|
|
}
|
|
for (i = 1; i <= num_wanted; i++) {
|
|
pat = wanted[i];
|
|
for (funcn in func_names) {
|
|
if ( funcn ~ pat && !accepted[funcn] ) {
|
|
num_functions++;
|
|
funcs_to_print[num_functions] = funcn;
|
|
accepted[funcn]++;
|
|
if ( "$group_by" != "all" ) {
|
|
printf(hdr_pat, funcn);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ( "$group_by" != "all" ) {
|
|
print "$group_by";
|
|
}
|
|
|
|
# groupby[] contains only files/pids that have been referenced by some
|
|
# functions, so we are automatically including only files that have some
|
|
# activity from wanted functions. We iterate through each function name
|
|
# and print the cell of the table.
|
|
for (thing in groupby) {
|
|
total_count = 0;
|
|
total_sizes = 0;
|
|
total_times = 0;
|
|
output = "";
|
|
for (i = 1; i <= num_functions; i++) {
|
|
funcn = funcs_to_print[i];
|
|
total_count += count[funcn "," thing];
|
|
total_sizes += sizes[funcn "," thing];
|
|
total_times += times[funcn "," thing];
|
|
result = $cell[funcn "," thing];
|
|
if ( "$func" == "avg" ) {
|
|
if ( count[funcn "," thing] > 0 ) {
|
|
result /= count[funcn "," thing];
|
|
}
|
|
else {
|
|
result = 0;
|
|
}
|
|
}
|
|
if ( "$group_by" != "all" ) {
|
|
output = output sprintf(col_pat, result);
|
|
}
|
|
else {
|
|
printf(col_pat funcn "\\n", result);
|
|
}
|
|
}
|
|
total_result = total_$cell;
|
|
if ( "$func" == "avg" ) {
|
|
if ( total_count > 0 ) {
|
|
total_result /= total_count;
|
|
}
|
|
else {
|
|
total_result = 0;
|
|
}
|
|
}
|
|
printf(col_pat, total_result);
|
|
if ( "$group_by" != "all" ) {
|
|
print(output thing);
|
|
}
|
|
else {
|
|
print "TOTAL";
|
|
}
|
|
}
|
|
}
|
|
EOF
|
|
|
|
awk -f $TMPDIR/summarize_strace.awk "$file" > $TMPDIR/summarized_samples
|
|
if [ "$group_by" != "all" ]; then
|
|
head -n1 $TMPDIR/summarized_samples
|
|
tail -n +2 $TMPDIR/summarized_samples | sort -rn -k1
|
|
else
|
|
grep TOTAL $TMPDIR/summarized_samples
|
|
grep -v TOTAL $TMPDIR/summarized_samples | sort -rn -k1
|
|
fi
|
|
}
|
|
|
|
main() {
|
|
if [ $# -gt 0 ]; then
|
|
# Summarize the files the user passed in.
|
|
tabulate_strace "$@" > $TMPDIR/tabulated_samples
|
|
else
|
|
# There's no file to analyze, so we'll make one.
|
|
if which strace > /dev/null 2>&1; then
|
|
|
|
local samples=${OPT_SAVE_SAMPLES:-"$TMPDIR/samples"}
|
|
|
|
# Get the PID of the process to profile, unless the user
|
|
# gave us it explicitly with --profile-pid.
|
|
local proc_pid="$OPT_PROFILE_PID"
|
|
if [ -z "$proc_pid" ]; then
|
|
proc_pid=$(_pidof "$OPT_PROFILE_PROCESS" | awk '{print $1; exit;'})
|
|
fi
|
|
|
|
date
|
|
|
|
if [ "$proc_pid" ]; then
|
|
echo "Tracing process ID $proc_pid"
|
|
|
|
_lsof "$proc_pid" > "$samples" 2>&1
|
|
if [ "$?" -ne "0" ]; then
|
|
echo "Error: could not execute lsof, error code $?"
|
|
exit 1
|
|
fi
|
|
|
|
strace -T -s 0 -f -p $proc_pid >> "$samples" 2>&1 &
|
|
if [ "$?" -ne "0" ]; then
|
|
echo "Error: could not execute strace, error code $?"
|
|
exit 1
|
|
fi
|
|
strace_pid=$!
|
|
# sleep one second then check to make sure the strace is
|
|
# actually running
|
|
sleep 1
|
|
ps -p $strace_pid > /dev/null 2>&1
|
|
if [ "$?" -ne "0" ]; then
|
|
echo "Cannot find strace process" >&2
|
|
tail "$samples" >&2
|
|
exit 1
|
|
fi
|
|
# sleep for interval -1, since we did a one second sleep
|
|
# before checking for the PID of strace
|
|
if [ $((${OPT_RUN_TIME}-1)) -gt 0 ]; then
|
|
sleep $((${OPT_RUN_TIME}-1))
|
|
fi
|
|
|
|
kill -s 2 $strace_pid
|
|
|
|
sleep 1
|
|
kill -s 15 $strace_pid 2>/dev/null
|
|
|
|
# Sometimes strace leaves threads/processes in T status.
|
|
kill -s 18 $proc_pid
|
|
|
|
# Summarize the output we just generated.
|
|
tabulate_strace "$samples" > $TMPDIR/tabulated_samples
|
|
else
|
|
echo "Cannot determine PID of $OPT_PROFILE_PROCESS process" >&2
|
|
exit 1
|
|
fi
|
|
else
|
|
echo "strace is not in PATH" >&2
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
summarize_strace \
|
|
$OPT_AGGREGATE \
|
|
$OPT_CELL \
|
|
$OPT_GROUP_BY \
|
|
"$TMPDIR/tabulated_samples"
|
|
}
|
|
|
|
# Execute the program if it was not included from another file.
|
|
# This makes it possible to include without executing, and thus test.
|
|
if [ "${0##*/}" = "$TOOL" ] \
|
|
|| [ "${0##*/}" = "bash" -a "$_" = "$0" ]; then
|
|
|
|
# Parse command line options. We must do this first so we can
|
|
# see if --daemonize was specified.
|
|
mk_tmpdir
|
|
parse_options "$0" "$@"
|
|
usage_or_errors "$0"
|
|
po_status=$?
|
|
if [ $po_status -eq 0 ]; then
|
|
# XXX
|
|
# TODO: This should be quoted but because the way parse_options()
|
|
# currently works, it flattens files in $@ (i.e. given on the cmd
|
|
# line) into the string $ARGV. So if we pass "$ARGV" then other
|
|
# functions will see 1 file named "file1 file2" instead of "file1"
|
|
# "file2".
|
|
main $ARGV
|
|
else
|
|
[ $OPT_ERRS -gt 0 ] && EXIT_STATUS=1
|
|
fi
|
|
rm_tmpdir
|
|
exit $EXIT_STATUS
|
|
fi
|
|
|
|
# ############################################################################
|
|
# Documentation
|
|
# ############################################################################
|
|
:<<'DOCUMENTATION'
|
|
=pod
|
|
|
|
=head1 NAME
|
|
|
|
pt-ioprofile - Watch process IO and print a table of file and I/O activity.
|
|
|
|
=head1 SYNOPSIS
|
|
|
|
Usage: pt-ioprofile [OPTIONS] [FILE]
|
|
|
|
pt-ioprofile does two things: 1) get lsof+strace for -s seconds, 2) aggregate
|
|
the result. If you specify a FILE, then step 1) is not performed.
|
|
|
|
=head1 RISKS
|
|
|
|
The following section is included to inform users about the potential risks,
|
|
whether known or unknown, of using this tool. The two main categories of risks
|
|
are those created by the nature of the tool (e.g. read-only tools vs. read-write
|
|
tools) and those created by bugs.
|
|
|
|
pt-ioprofile is a read-only tool, so your data is not at risk. However, it works
|
|
by attaching C<strace> to the process using C<ptrace()>, which will make it run
|
|
very slowly until C<strace> detaches. In addition to freezing the server, there
|
|
is also some risk of the process crashing or performing badly after C<strace>
|
|
detaches from it, or indeed of C<strace> not detaching cleanly and leaving the
|
|
process in a sleeping state. As a result, this should be considered an
|
|
intrusive tool, and should not be used on production servers unless you are
|
|
comfortable with that.
|
|
|
|
At the time of this release, we know of no bugs that could cause serious harm
|
|
to users.
|
|
|
|
The authoritative source for updated information is always the online issue
|
|
tracking system. Issues that affect this tool will be marked as such. You can
|
|
see a list of such issues at the following URL:
|
|
L<http://www.percona.com/bugs/pt-ioprofile>.
|
|
|
|
See also L<"BUGS"> for more information on filing bugs and getting help.
|
|
|
|
=head1 DESCRIPTION
|
|
|
|
pt-ioprofile uses C<strace> and C<lsof> to watch a process's IO and print out
|
|
a table of files and I/O activity. By default, it watches the mysqld
|
|
process for 30 seconds. The output is like:
|
|
|
|
Tue Dec 27 15:33:57 PST 2011
|
|
Tracing process ID 1833
|
|
total read write lseek ftruncate filename
|
|
0.000150 0.000029 0.000068 0.000038 0.000015 /tmp/ibBE5opS
|
|
|
|
You probably need to run this tool as root.
|
|
|
|
=head1 OPTIONS
|
|
|
|
=over
|
|
|
|
=item --aggregate
|
|
|
|
short form: -a; type: string; default: sum
|
|
|
|
The aggregate function, either C<sum> or C<avg>.
|
|
|
|
If sum, then each cell will contain the sum of the values in it.
|
|
If avg, then each cell will contain the average of the values in it.
|
|
|
|
=item --cell
|
|
|
|
short form: -c; type: string; default: times
|
|
|
|
The cell contents.
|
|
|
|
Valid values are:
|
|
|
|
VALUE CELLS CONTAIN
|
|
===== =======================
|
|
count Count of I/O operations
|
|
sizes Sizes of I/O operations
|
|
times I/O operation timing
|
|
|
|
=item --group-by
|
|
|
|
short form: -g; type: string; default: filename
|
|
|
|
The group-by item.
|
|
|
|
Valid values are:
|
|
|
|
VALUE GROUPING
|
|
===== ======================================
|
|
all Summarize into a single line of output
|
|
filename One line of output per filename
|
|
pid One line of output per process ID
|
|
|
|
=item --help
|
|
|
|
Print help and exit.
|
|
|
|
=item --profile-pid
|
|
|
|
short form: -p; type: int
|
|
|
|
The PID to profile, overrides L<"--profile-process">.
|
|
|
|
=item --profile-process
|
|
|
|
short form: -b; type: string; default: mysqld
|
|
|
|
The process name to profile.
|
|
|
|
=item --run-time
|
|
|
|
type: int; default: 30
|
|
|
|
How long to profile.
|
|
|
|
=item --save-samples
|
|
|
|
type: string
|
|
|
|
Filename to save samples in; these can be used for later analysis.
|
|
|
|
=item --version
|
|
|
|
Print the tool's version and exit.
|
|
|
|
=back
|
|
|
|
=head1 ENVIRONMENT
|
|
|
|
This tool does not use any environment variables.
|
|
|
|
=head1 SYSTEM REQUIREMENTS
|
|
|
|
This tool requires the Bourne shell (F</bin/sh>).
|
|
|
|
=head1 BUGS
|
|
|
|
For a list of known bugs, see L<http://www.percona.com/bugs/pt-ioprofile>.
|
|
|
|
Please report bugs at L<https://bugs.launchpad.net/percona-toolkit>.
|
|
Include the following information in your bug report:
|
|
|
|
=over
|
|
|
|
=item * Complete command-line used to run the tool
|
|
|
|
=item * Tool L<"--version">
|
|
|
|
=item * MySQL version of all servers involved
|
|
|
|
=item * Output from the tool including STDERR
|
|
|
|
=item * Input files (log/dump/config files, etc.)
|
|
|
|
=back
|
|
|
|
If possible, include debugging output by running the tool with C<PTDEBUG>;
|
|
see L<"ENVIRONMENT">.
|
|
|
|
=head1 DOWNLOADING
|
|
|
|
Visit L<http://www.percona.com/software/percona-toolkit/> to download the
|
|
latest release of Percona Toolkit. Or, get the latest release from the
|
|
command line:
|
|
|
|
wget percona.com/get/percona-toolkit.tar.gz
|
|
|
|
wget percona.com/get/percona-toolkit.rpm
|
|
|
|
wget percona.com/get/percona-toolkit.deb
|
|
|
|
You can also get individual tools from the latest release:
|
|
|
|
wget percona.com/get/TOOL
|
|
|
|
Replace C<TOOL> with the name of any tool.
|
|
|
|
=head1 AUTHORS
|
|
|
|
Baron Schwartz
|
|
|
|
=head1 ABOUT PERCONA TOOLKIT
|
|
|
|
This tool is part of Percona Toolkit, a collection of advanced command-line
|
|
tools developed by Percona for MySQL support and consulting. Percona Toolkit
|
|
was forked from two projects in June, 2011: Maatkit and Aspersa. Those
|
|
projects were created by Baron Schwartz and developed primarily by him and
|
|
Daniel Nichter, both of whom are employed by Percona. Visit
|
|
L<http://www.percona.com/software/> for more software developed by Percona.
|
|
|
|
=head1 COPYRIGHT, LICENSE, AND WARRANTY
|
|
|
|
This program is copyright 2010-2011 Baron Schwartz, 2011-2012 Percona Inc.
|
|
Feedback and improvements are welcome.
|
|
|
|
THIS PROGRAM IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
|
|
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
|
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
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, version 2; OR the Perl Artistic License. On UNIX and similar
|
|
systems, you can issue `man perlgpl' or `man perlartistic' to read these
|
|
licenses.
|
|
|
|
You should have received a copy of the GNU General Public License along with
|
|
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
|
|
Place, Suite 330, Boston, MA 02111-1307 USA.
|
|
|
|
=head1 VERSION
|
|
|
|
pt-ioprofile 2.1.1
|
|
|
|
=cut
|
|
|
|
DOCUMENTATION
|