16c00db4bb
Pull AFS fixes from David Howells:
"Here's a set of patches that fix a number of bugs in the in-kernel AFS
client, including:
- Fix directory locking to not use individual page locks for
directory reading/scanning but rather to use a semaphore on the
afs_vnode struct as the directory contents must be read in a single
blob and data from different reads must not be mixed as the entire
contents may be shuffled about between reads.
- Fix address list parsing to handle port specifiers correctly.
- Only give up callback records on a server if we actually talked to
that server (we might not be able to access a server).
- Fix some callback handling bugs, including refcounting,
whole-volume callbacks and when callbacks actually get broken in
response to a CB.CallBack op.
- Fix some server/address rotation bugs, including giving up if we
can't probe a server; giving up if a server says it doesn't have a
volume, but there are more servers to try.
- Fix the decoding of fetched statuses to be OpenAFS compatible.
- Fix the handling of server lookups in Cache Manager ops (such as
CB.InitCallBackState3) to use a UUID if possible and to handle no
server being found.
- Fix a bug in server lookup where not all addresses are compared.
- Fix the non-encryption of calls that prevents some servers from
being accessed (this also requires an AF_RXRPC patch that has
already gone in through the net tree).
There's also a patch that adds tracepoints to log Cache Manager ops
that don't find a matching server, either by UUID or by address"
* tag 'afs-fixes-20180514' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs:
afs: Fix the non-encryption of calls
afs: Fix CB.CallBack handling
afs: Fix whole-volume callback handling
afs: Fix afs_find_server search loop
afs: Fix the handling of an unfound server in CM operations
afs: Add a tracepoint to record callbacks from unlisted servers
afs: Fix the handling of CB.InitCallBackState3 to find the server by UUID
afs: Fix VNOVOL handling in address rotation
afs: Fix AFSFetchStatus decoder to provide OpenAFS compatibility
afs: Fix server rotation's handling of fileserver probe failure
afs: Fix refcounting in callback registration
afs: Fix giving up callbacks on server destruction
afs: Fix address list parsing
afs: Fix directory page locking
126 lines
4.3 KiB
Python
Executable file
126 lines
4.3 KiB
Python
Executable file
# stackcollapse.py - format perf samples with one line per distinct call stack
|
|
# SPDX-License-Identifier: GPL-2.0
|
|
#
|
|
# This script's output has two space-separated fields. The first is a semicolon
|
|
# separated stack including the program name (from the "comm" field) and the
|
|
# function names from the call stack. The second is a count:
|
|
#
|
|
# swapper;start_kernel;rest_init;cpu_idle;default_idle;native_safe_halt 2
|
|
#
|
|
# The file is sorted according to the first field.
|
|
#
|
|
# Input may be created and processed using:
|
|
#
|
|
# perf record -a -g -F 99 sleep 60
|
|
# perf script report stackcollapse > out.stacks-folded
|
|
#
|
|
# (perf script record stackcollapse works too).
|
|
#
|
|
# Written by Paolo Bonzini <pbonzini@redhat.com>
|
|
# Based on Brendan Gregg's stackcollapse-perf.pl script.
|
|
|
|
import os
|
|
import sys
|
|
from collections import defaultdict
|
|
from optparse import OptionParser, make_option
|
|
|
|
sys.path.append(os.environ['PERF_EXEC_PATH'] + \
|
|
'/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
|
|
|
|
from perf_trace_context import *
|
|
from Core import *
|
|
from EventClass import *
|
|
|
|
# command line parsing
|
|
|
|
option_list = [
|
|
# formatting options for the bottom entry of the stack
|
|
make_option("--include-tid", dest="include_tid",
|
|
action="store_true", default=False,
|
|
help="include thread id in stack"),
|
|
make_option("--include-pid", dest="include_pid",
|
|
action="store_true", default=False,
|
|
help="include process id in stack"),
|
|
make_option("--no-comm", dest="include_comm",
|
|
action="store_false", default=True,
|
|
help="do not separate stacks according to comm"),
|
|
make_option("--tidy-java", dest="tidy_java",
|
|
action="store_true", default=False,
|
|
help="beautify Java signatures"),
|
|
make_option("--kernel", dest="annotate_kernel",
|
|
action="store_true", default=False,
|
|
help="annotate kernel functions with _[k]")
|
|
]
|
|
|
|
parser = OptionParser(option_list=option_list)
|
|
(opts, args) = parser.parse_args()
|
|
|
|
if len(args) != 0:
|
|
parser.error("unexpected command line argument")
|
|
if opts.include_tid and not opts.include_comm:
|
|
parser.error("requesting tid but not comm is invalid")
|
|
if opts.include_pid and not opts.include_comm:
|
|
parser.error("requesting pid but not comm is invalid")
|
|
|
|
# event handlers
|
|
|
|
lines = defaultdict(lambda: 0)
|
|
|
|
def process_event(param_dict):
|
|
def tidy_function_name(sym, dso):
|
|
if sym is None:
|
|
sym = '[unknown]'
|
|
|
|
sym = sym.replace(';', ':')
|
|
if opts.tidy_java:
|
|
# the original stackcollapse-perf.pl script gives the
|
|
# example of converting this:
|
|
# Lorg/mozilla/javascript/MemberBox;.<init>(Ljava/lang/reflect/Method;)V
|
|
# to this:
|
|
# org/mozilla/javascript/MemberBox:.init
|
|
sym = sym.replace('<', '')
|
|
sym = sym.replace('>', '')
|
|
if sym[0] == 'L' and sym.find('/'):
|
|
sym = sym[1:]
|
|
try:
|
|
sym = sym[:sym.index('(')]
|
|
except ValueError:
|
|
pass
|
|
|
|
if opts.annotate_kernel and dso == '[kernel.kallsyms]':
|
|
return sym + '_[k]'
|
|
else:
|
|
return sym
|
|
|
|
stack = list()
|
|
if 'callchain' in param_dict:
|
|
for entry in param_dict['callchain']:
|
|
entry.setdefault('sym', dict())
|
|
entry['sym'].setdefault('name', None)
|
|
entry.setdefault('dso', None)
|
|
stack.append(tidy_function_name(entry['sym']['name'],
|
|
entry['dso']))
|
|
else:
|
|
param_dict.setdefault('symbol', None)
|
|
param_dict.setdefault('dso', None)
|
|
stack.append(tidy_function_name(param_dict['symbol'],
|
|
param_dict['dso']))
|
|
|
|
if opts.include_comm:
|
|
comm = param_dict["comm"].replace(' ', '_')
|
|
sep = "-"
|
|
if opts.include_pid:
|
|
comm = comm + sep + str(param_dict['sample']['pid'])
|
|
sep = "/"
|
|
if opts.include_tid:
|
|
comm = comm + sep + str(param_dict['sample']['tid'])
|
|
stack.append(comm)
|
|
|
|
stack_string = ';'.join(reversed(stack))
|
|
lines[stack_string] = lines[stack_string] + 1
|
|
|
|
def trace_end():
|
|
list = lines.keys()
|
|
list.sort()
|
|
for stack in list:
|
|
print "%s %d" % (stack, lines[stack])
|