Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 72f4a11d2fb16792f5e5107922652366194cfd66

Authored by Ingo Molnar 2013-09-06 20:08:08 +0800

Exists in smarc-imx_3.14.28_1.0.0_ga and in 1 other branch

Merge tag 'perf-urgent-for-mingo' of git://git.kernel.org/pub/scm/linux/kernel/g…

…it/acme/linux into perf/urgent

Pull perf/urgent fixes from Arnaldo Carvalho de Melo:

 * Fix parsing with no sample_id_all bit set, this regression prevents perf
   from reading old perf.data files generated in systems where
   perf_event_attr.sample_id_all isn't available, from Adrian Hunter.

 * Add signal checking to the inner 'perf trace' event processing loop, allowing
   faster response to control+C.

 * Fix formatting of long symbol names removing the hardcoding of a buffer
   size used to format histogram entries, which was truncating the lines.

 * Separate progress bar update when processing events, reducing potentially big
   overhead in not needed TUI progress bar screen updates, from Jiri Olsa.

 * Fix 'perf trace' build in architectures where MAP_32BIT is not defined, from
   Kyle McMartin.

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@kernel.org>

Showing 8 changed files Inline Diff

tools/perf/Makefile
tools/perf/builtin-trace.c
tools/perf/tests/builtin-test.c
tools/perf/tests/parse-no-sample-id-all.c
tools/perf/tests/tests.h
tools/perf/ui/stdio/hist.c
tools/perf/util/evlist.c
tools/perf/util/session.c

tools/perf/Makefile

Diff comments View file @ 72f4a11

 include ../scripts/Makefile.include
 # The default target of this Makefile is...
 all:
 include config/utilities.mak
 # Define V to have a more verbose compile.
 #
 # Define O to save output files in a separate directory.
 #
 # Define ARCH as name of target architecture if you want cross-builds.
 #
 # Define CROSS_COMPILE as prefix name of compiler if you want cross-builds.
 #
 # Define NO_LIBPERL to disable perl script extension.
 #
 # Define NO_LIBPYTHON to disable python script extension.
 #
 # Define PYTHON to point to the python binary if the default
 # `python' is not correct; for example: PYTHON=python2
 #
 # Define PYTHON_CONFIG to point to the python-config binary if
 # the default `$(PYTHON)-config' is not correct.
 #
 # Define ASCIIDOC8 if you want to format documentation with AsciiDoc 8
 #
 # Define DOCBOOK_XSL_172 if you want to format man pages with DocBook XSL v1.72.
 #
 # Define LDFLAGS=-static to build a static binary.
 #
 # Define EXTRA_CFLAGS=-m64 or EXTRA_CFLAGS=-m32 as appropriate for cross-builds.
 #
 # Define NO_DWARF if you do not want debug-info analysis feature at all.
 #
 # Define WERROR=0 to disable treating any warnings as errors.
 #
 # Define NO_NEWT if you do not want TUI support. (deprecated)
 #
 # Define NO_SLANG if you do not want TUI support.
 #
 # Define NO_GTK2 if you do not want GTK+ GUI support.
 #
 # Define NO_DEMANGLE if you do not want C++ symbol demangling.
 #
 # Define NO_LIBELF if you do not want libelf dependency (e.g. cross-builds)
 #
 # Define NO_LIBUNWIND if you do not want libunwind dependency for dwarf
 # backtrace post unwind.
 #
 # Define NO_BACKTRACE if you do not want stack backtrace debug feature
 #
 # Define NO_LIBNUMA if you do not want numa perf benchmark
 #
 # Define NO_LIBAUDIT if you do not want libaudit support
 #
 # Define NO_LIBBIONIC if you do not want bionic support
 ifeq ($(srctree),)
 srctree := $(patsubst %/,%,$(dir $(shell pwd)))
 srctree := $(patsubst %/,%,$(dir $(srctree)))
 #$(info Determined 'srctree' to be $(srctree))
 endif
 ifneq ($(objtree),)
 #$(info Determined 'objtree' to be $(objtree))
 endif
 ifneq ($(OUTPUT),)
 #$(info Determined 'OUTPUT' to be $(OUTPUT))
 endif
 $(OUTPUT)PERF-VERSION-FILE: .FORCE-PERF-VERSION-FILE
 	@$(SHELL_PATH) util/PERF-VERSION-GEN $(OUTPUT)
 CC = $(CROSS_COMPILE)gcc
 AR = $(CROSS_COMPILE)ar
 RM      = rm -f
 MKDIR   = mkdir
 FIND    = find
 INSTALL = install
 FLEX    = flex
 BISON   = bison
 STRIP   = strip
 LK_DIR          = $(srctree)/tools/lib/lk/
 TRACE_EVENT_DIR = $(srctree)/tools/lib/traceevent/
 # include config/Makefile by default and rule out
 # non-config cases
 config := 1
 NON_CONFIG_TARGETS := clean TAGS tags cscope help
 ifdef MAKECMDGOALS
 ifeq ($(filter-out $(NON_CONFIG_TARGETS),$(MAKECMDGOALS)),)
   config := 0
 endif
 endif
 ifeq ($(config),1)
 include config/Makefile
 endif
 export prefix bindir sharedir sysconfdir
 # sparse is architecture-neutral, which means that we need to tell it
 # explicitly what architecture to check for. Fix this up for yours..
 SPARSE_FLAGS = -D__BIG_ENDIAN__ -D__powerpc__
 # Guard against environment variables
 BUILTIN_OBJS =
 LIB_H =
 LIB_OBJS =
 PYRF_OBJS =
 SCRIPT_SH =
 SCRIPT_SH += perf-archive.sh
 grep-libs = $(filter -l%,$(1))
 strip-libs = $(filter-out -l%,$(1))
 ifneq ($(OUTPUT),)
   TE_PATH=$(OUTPUT)
 ifneq ($(subdir),)
   LK_PATH=$(OUTPUT)/../lib/lk/
 else
   LK_PATH=$(OUTPUT)
 endif
 else
   TE_PATH=$(TRACE_EVENT_DIR)
   LK_PATH=$(LK_DIR)
 endif
 LIBTRACEEVENT = $(TE_PATH)libtraceevent.a
 export LIBTRACEEVENT
 LIBLK = $(LK_PATH)liblk.a
 export LIBLK
 # python extension build directories
 PYTHON_EXTBUILD     := $(OUTPUT)python_ext_build/
 PYTHON_EXTBUILD_LIB := $(PYTHON_EXTBUILD)lib/
 PYTHON_EXTBUILD_TMP := $(PYTHON_EXTBUILD)tmp/
 export PYTHON_EXTBUILD_LIB PYTHON_EXTBUILD_TMP
 python-clean := rm -rf $(PYTHON_EXTBUILD) $(OUTPUT)python/perf.so
 PYTHON_EXT_SRCS := $(shell grep -v ^\# util/python-ext-sources)
 PYTHON_EXT_DEPS := util/python-ext-sources util/setup.py $(LIBTRACEEVENT) $(LIBLK)
 $(OUTPUT)python/perf.so: $(PYTHON_EXT_SRCS) $(PYTHON_EXT_DEPS)
 	$(QUIET_GEN)CFLAGS='$(CFLAGS)' $(PYTHON_WORD) util/setup.py \
 	  --quiet build_ext; \
 	mkdir -p $(OUTPUT)python && \
 	cp $(PYTHON_EXTBUILD_LIB)perf.so $(OUTPUT)python/
 #
 # No Perl scripts right now:
 #
 SCRIPTS = $(patsubst %.sh,%,$(SCRIPT_SH))
 #
 # Single 'perf' binary right now:
 #
 PROGRAMS += $(OUTPUT)perf
 # what 'all' will build and 'install' will install, in perfexecdir
 ALL_PROGRAMS = $(PROGRAMS) $(SCRIPTS)
 # what 'all' will build but not install in perfexecdir
 OTHER_PROGRAMS = $(OUTPUT)perf
 # Set paths to tools early so that they can be used for version tests.
 ifndef SHELL_PATH
   SHELL_PATH = /bin/sh
 endif
 ifndef PERL_PATH
   PERL_PATH = /usr/bin/perl
 endif
 export PERL_PATH
 $(OUTPUT)util/parse-events-flex.c: util/parse-events.l $(OUTPUT)util/parse-events-bison.c
 	$(QUIET_FLEX)$(FLEX) --header-file=$(OUTPUT)util/parse-events-flex.h $(PARSER_DEBUG_FLEX) -t util/parse-events.l > $(OUTPUT)util/parse-events-flex.c
 $(OUTPUT)util/parse-events-bison.c: util/parse-events.y
 	$(QUIET_BISON)$(BISON) -v util/parse-events.y -d $(PARSER_DEBUG_BISON) -o $(OUTPUT)util/parse-events-bison.c -p parse_events_
 $(OUTPUT)util/pmu-flex.c: util/pmu.l $(OUTPUT)util/pmu-bison.c
 	$(QUIET_FLEX)$(FLEX) --header-file=$(OUTPUT)util/pmu-flex.h -t util/pmu.l > $(OUTPUT)util/pmu-flex.c
 $(OUTPUT)util/pmu-bison.c: util/pmu.y
 	$(QUIET_BISON)$(BISON) -v util/pmu.y -d -o $(OUTPUT)util/pmu-bison.c -p perf_pmu_
 $(OUTPUT)util/parse-events.o: $(OUTPUT)util/parse-events-flex.c $(OUTPUT)util/parse-events-bison.c
 $(OUTPUT)util/pmu.o: $(OUTPUT)util/pmu-flex.c $(OUTPUT)util/pmu-bison.c
 LIB_FILE=$(OUTPUT)libperf.a
 LIB_H += ../../include/uapi/linux/perf_event.h
 LIB_H += ../../include/linux/rbtree.h
 LIB_H += ../../include/linux/list.h
 LIB_H += ../../include/uapi/linux/const.h
 LIB_H += ../../include/linux/hash.h
 LIB_H += ../../include/linux/stringify.h
 LIB_H += util/include/linux/bitmap.h
 LIB_H += util/include/linux/bitops.h
 LIB_H += util/include/linux/compiler.h
 LIB_H += util/include/linux/const.h
 LIB_H += util/include/linux/ctype.h
 LIB_H += util/include/linux/kernel.h
 LIB_H += util/include/linux/list.h
 LIB_H += util/include/linux/export.h
 LIB_H += util/include/linux/magic.h
 LIB_H += util/include/linux/poison.h
 LIB_H += util/include/linux/prefetch.h
 LIB_H += util/include/linux/rbtree.h
 LIB_H += util/include/linux/rbtree_augmented.h
 LIB_H += util/include/linux/string.h
 LIB_H += util/include/linux/types.h
 LIB_H += util/include/linux/linkage.h
 LIB_H += util/include/asm/asm-offsets.h
 LIB_H += util/include/asm/bug.h
 LIB_H += util/include/asm/byteorder.h
 LIB_H += util/include/asm/hweight.h
 LIB_H += util/include/asm/swab.h
 LIB_H += util/include/asm/system.h
 LIB_H += util/include/asm/uaccess.h
 LIB_H += util/include/dwarf-regs.h
 LIB_H += util/include/asm/dwarf2.h
 LIB_H += util/include/asm/cpufeature.h
 LIB_H += util/include/asm/unistd_32.h
 LIB_H += util/include/asm/unistd_64.h
 LIB_H += perf.h
 LIB_H += util/annotate.h
 LIB_H += util/cache.h
 LIB_H += util/callchain.h
 LIB_H += util/build-id.h
 LIB_H += util/debug.h
 LIB_H += util/sysfs.h
 LIB_H += util/pmu.h
 LIB_H += util/event.h
 LIB_H += util/evsel.h
 LIB_H += util/evlist.h
 LIB_H += util/exec_cmd.h
 LIB_H += util/types.h
 LIB_H += util/levenshtein.h
 LIB_H += util/machine.h
 LIB_H += util/map.h
 LIB_H += util/parse-options.h
 LIB_H += util/parse-events.h
 LIB_H += util/quote.h
 LIB_H += util/util.h
 LIB_H += util/xyarray.h
 LIB_H += util/header.h
 LIB_H += util/help.h
 LIB_H += util/session.h
 LIB_H += util/strbuf.h
 LIB_H += util/strlist.h
 LIB_H += util/strfilter.h
 LIB_H += util/svghelper.h
 LIB_H += util/tool.h
 LIB_H += util/run-command.h
 LIB_H += util/sigchain.h
 LIB_H += util/dso.h
 LIB_H += util/symbol.h
 LIB_H += util/color.h
 LIB_H += util/values.h
 LIB_H += util/sort.h
 LIB_H += util/hist.h
 LIB_H += util/thread.h
 LIB_H += util/thread_map.h
 LIB_H += util/trace-event.h
 LIB_H += util/probe-finder.h
 LIB_H += util/dwarf-aux.h
 LIB_H += util/probe-event.h
 LIB_H += util/pstack.h
 LIB_H += util/cpumap.h
 LIB_H += util/top.h
 LIB_H += $(ARCH_INCLUDE)
 LIB_H += util/cgroup.h
 LIB_H += $(LIB_INCLUDE)traceevent/event-parse.h
 LIB_H += util/target.h
 LIB_H += util/rblist.h
 LIB_H += util/intlist.h
 LIB_H += util/perf_regs.h
 LIB_H += util/unwind.h
 LIB_H += util/vdso.h
 LIB_H += ui/helpline.h
 LIB_H += ui/progress.h
 LIB_H += ui/util.h
 LIB_H += ui/ui.h
 LIB_OBJS += $(OUTPUT)util/abspath.o
 LIB_OBJS += $(OUTPUT)util/alias.o
 LIB_OBJS += $(OUTPUT)util/annotate.o
 LIB_OBJS += $(OUTPUT)util/build-id.o
 LIB_OBJS += $(OUTPUT)util/config.o
 LIB_OBJS += $(OUTPUT)util/ctype.o
 LIB_OBJS += $(OUTPUT)util/sysfs.o
 LIB_OBJS += $(OUTPUT)util/pmu.o
 LIB_OBJS += $(OUTPUT)util/environment.o
 LIB_OBJS += $(OUTPUT)util/event.o
 LIB_OBJS += $(OUTPUT)util/evlist.o
 LIB_OBJS += $(OUTPUT)util/evsel.o
 LIB_OBJS += $(OUTPUT)util/exec_cmd.o
 LIB_OBJS += $(OUTPUT)util/help.o
 LIB_OBJS += $(OUTPUT)util/levenshtein.o
 LIB_OBJS += $(OUTPUT)util/parse-options.o
 LIB_OBJS += $(OUTPUT)util/parse-events.o
 LIB_OBJS += $(OUTPUT)util/path.o
 LIB_OBJS += $(OUTPUT)util/rbtree.o
 LIB_OBJS += $(OUTPUT)util/bitmap.o
 LIB_OBJS += $(OUTPUT)util/hweight.o
 LIB_OBJS += $(OUTPUT)util/run-command.o
 LIB_OBJS += $(OUTPUT)util/quote.o
 LIB_OBJS += $(OUTPUT)util/strbuf.o
 LIB_OBJS += $(OUTPUT)util/string.o
 LIB_OBJS += $(OUTPUT)util/strlist.o
 LIB_OBJS += $(OUTPUT)util/strfilter.o
 LIB_OBJS += $(OUTPUT)util/top.o
 LIB_OBJS += $(OUTPUT)util/usage.o
 LIB_OBJS += $(OUTPUT)util/wrapper.o
 LIB_OBJS += $(OUTPUT)util/sigchain.o
 LIB_OBJS += $(OUTPUT)util/dso.o
 LIB_OBJS += $(OUTPUT)util/symbol.o
 LIB_OBJS += $(OUTPUT)util/symbol-elf.o
 LIB_OBJS += $(OUTPUT)util/color.o
 LIB_OBJS += $(OUTPUT)util/pager.o
 LIB_OBJS += $(OUTPUT)util/header.o
 LIB_OBJS += $(OUTPUT)util/callchain.o
 LIB_OBJS += $(OUTPUT)util/values.o
 LIB_OBJS += $(OUTPUT)util/debug.o
 LIB_OBJS += $(OUTPUT)util/machine.o
 LIB_OBJS += $(OUTPUT)util/map.o
 LIB_OBJS += $(OUTPUT)util/pstack.o
 LIB_OBJS += $(OUTPUT)util/session.o
 LIB_OBJS += $(OUTPUT)util/thread.o
 LIB_OBJS += $(OUTPUT)util/thread_map.o
 LIB_OBJS += $(OUTPUT)util/trace-event-parse.o
 LIB_OBJS += $(OUTPUT)util/parse-events-flex.o
 LIB_OBJS += $(OUTPUT)util/parse-events-bison.o
 LIB_OBJS += $(OUTPUT)util/pmu-flex.o
 LIB_OBJS += $(OUTPUT)util/pmu-bison.o
 LIB_OBJS += $(OUTPUT)util/trace-event-read.o
 LIB_OBJS += $(OUTPUT)util/trace-event-info.o
 LIB_OBJS += $(OUTPUT)util/trace-event-scripting.o
 LIB_OBJS += $(OUTPUT)util/svghelper.o
 LIB_OBJS += $(OUTPUT)util/sort.o
 LIB_OBJS += $(OUTPUT)util/hist.o
 LIB_OBJS += $(OUTPUT)util/probe-event.o
 LIB_OBJS += $(OUTPUT)util/util.o
 LIB_OBJS += $(OUTPUT)util/xyarray.o
 LIB_OBJS += $(OUTPUT)util/cpumap.o
 LIB_OBJS += $(OUTPUT)util/cgroup.o
 LIB_OBJS += $(OUTPUT)util/target.o
 LIB_OBJS += $(OUTPUT)util/rblist.o
 LIB_OBJS += $(OUTPUT)util/intlist.o
 LIB_OBJS += $(OUTPUT)util/vdso.o
 LIB_OBJS += $(OUTPUT)util/stat.o
 LIB_OBJS += $(OUTPUT)util/record.o
 LIB_OBJS += $(OUTPUT)ui/setup.o
 LIB_OBJS += $(OUTPUT)ui/helpline.o
 LIB_OBJS += $(OUTPUT)ui/progress.o
 LIB_OBJS += $(OUTPUT)ui/util.o
 LIB_OBJS += $(OUTPUT)ui/hist.o
 LIB_OBJS += $(OUTPUT)ui/stdio/hist.o
 LIB_OBJS += $(OUTPUT)arch/common.o
 LIB_OBJS += $(OUTPUT)tests/parse-events.o
 LIB_OBJS += $(OUTPUT)tests/dso-data.o
 LIB_OBJS += $(OUTPUT)tests/attr.o
 LIB_OBJS += $(OUTPUT)tests/vmlinux-kallsyms.o
 LIB_OBJS += $(OUTPUT)tests/open-syscall.o
 LIB_OBJS += $(OUTPUT)tests/open-syscall-all-cpus.o
 LIB_OBJS += $(OUTPUT)tests/open-syscall-tp-fields.o
 LIB_OBJS += $(OUTPUT)tests/mmap-basic.o
 LIB_OBJS += $(OUTPUT)tests/perf-record.o
 LIB_OBJS += $(OUTPUT)tests/rdpmc.o
 LIB_OBJS += $(OUTPUT)tests/evsel-roundtrip-name.o
 LIB_OBJS += $(OUTPUT)tests/evsel-tp-sched.o
 LIB_OBJS += $(OUTPUT)tests/pmu.o
 LIB_OBJS += $(OUTPUT)tests/hists_link.o
 LIB_OBJS += $(OUTPUT)tests/python-use.o
 LIB_OBJS += $(OUTPUT)tests/bp_signal.o
 LIB_OBJS += $(OUTPUT)tests/bp_signal_overflow.o
 LIB_OBJS += $(OUTPUT)tests/task-exit.o
 LIB_OBJS += $(OUTPUT)tests/sw-clock.o
 ifeq ($(ARCH),x86)
 LIB_OBJS += $(OUTPUT)tests/perf-time-to-tsc.o
 endif
 LIB_OBJS += $(OUTPUT)tests/code-reading.o
+LIB_OBJS += $(OUTPUT)tests/sample-parsing.o
+LIB_OBJS += $(OUTPUT)tests/parse-no-sample-id-all.o
 BUILTIN_OBJS += $(OUTPUT)builtin-annotate.o
 BUILTIN_OBJS += $(OUTPUT)builtin-bench.o
 # Benchmark modules
 BUILTIN_OBJS += $(OUTPUT)bench/sched-messaging.o
 BUILTIN_OBJS += $(OUTPUT)bench/sched-pipe.o
 ifeq ($(RAW_ARCH),x86_64)
 BUILTIN_OBJS += $(OUTPUT)bench/mem-memcpy-x86-64-asm.o
 BUILTIN_OBJS += $(OUTPUT)bench/mem-memset-x86-64-asm.o
 endif
 BUILTIN_OBJS += $(OUTPUT)bench/mem-memcpy.o
 BUILTIN_OBJS += $(OUTPUT)bench/mem-memset.o
 BUILTIN_OBJS += $(OUTPUT)builtin-diff.o
 BUILTIN_OBJS += $(OUTPUT)builtin-evlist.o
 BUILTIN_OBJS += $(OUTPUT)builtin-help.o
 BUILTIN_OBJS += $(OUTPUT)builtin-sched.o
 BUILTIN_OBJS += $(OUTPUT)builtin-buildid-list.o
 BUILTIN_OBJS += $(OUTPUT)builtin-buildid-cache.o
 BUILTIN_OBJS += $(OUTPUT)builtin-list.o
 BUILTIN_OBJS += $(OUTPUT)builtin-record.o
 BUILTIN_OBJS += $(OUTPUT)builtin-report.o
 BUILTIN_OBJS += $(OUTPUT)builtin-stat.o
 BUILTIN_OBJS += $(OUTPUT)builtin-timechart.o
 BUILTIN_OBJS += $(OUTPUT)builtin-top.o
 BUILTIN_OBJS += $(OUTPUT)builtin-script.o
 BUILTIN_OBJS += $(OUTPUT)builtin-probe.o
 BUILTIN_OBJS += $(OUTPUT)builtin-kmem.o
 BUILTIN_OBJS += $(OUTPUT)builtin-lock.o
 BUILTIN_OBJS += $(OUTPUT)builtin-kvm.o
 BUILTIN_OBJS += $(OUTPUT)builtin-inject.o
 BUILTIN_OBJS += $(OUTPUT)tests/builtin-test.o
 BUILTIN_OBJS += $(OUTPUT)builtin-mem.o
 PERFLIBS = $(LIB_FILE) $(LIBLK) $(LIBTRACEEVENT)
 # We choose to avoid "if .. else if .. else .. endif endif"
 # because maintaining the nesting to match is a pain.  If
 # we had "elif" things would have been much nicer...
 -include arch/$(ARCH)/Makefile
 ifneq ($(OUTPUT),)
   CFLAGS += -I$(OUTPUT)
 endif
-LIB_OBJS += $(OUTPUT)tests/sample-parsing.o
 ifdef NO_LIBELF
 EXTLIBS := $(filter-out -lelf,$(EXTLIBS))
 # Remove ELF/DWARF dependent codes
 LIB_OBJS := $(filter-out $(OUTPUT)util/symbol-elf.o,$(LIB_OBJS))
 LIB_OBJS := $(filter-out $(OUTPUT)util/dwarf-aux.o,$(LIB_OBJS))
 LIB_OBJS := $(filter-out $(OUTPUT)util/probe-event.o,$(LIB_OBJS))
 LIB_OBJS := $(filter-out $(OUTPUT)util/probe-finder.o,$(LIB_OBJS))
 BUILTIN_OBJS := $(filter-out $(OUTPUT)builtin-probe.o,$(BUILTIN_OBJS))
 # Use minimal symbol handling
 LIB_OBJS += $(OUTPUT)util/symbol-minimal.o
 else # NO_LIBELF
 ifndef NO_DWARF
   LIB_OBJS += $(OUTPUT)util/probe-finder.o
   LIB_OBJS += $(OUTPUT)util/dwarf-aux.o
 endif # NO_DWARF
 endif # NO_LIBELF
 ifndef NO_LIBUNWIND
   LIB_OBJS += $(OUTPUT)util/unwind.o
 endif
 LIB_OBJS += $(OUTPUT)tests/keep-tracking.o
 ifndef NO_LIBAUDIT
   BUILTIN_OBJS += $(OUTPUT)builtin-trace.o
 endif
 ifndef NO_SLANG
   LIB_OBJS += $(OUTPUT)ui/browser.o
   LIB_OBJS += $(OUTPUT)ui/browsers/annotate.o
   LIB_OBJS += $(OUTPUT)ui/browsers/hists.o
   LIB_OBJS += $(OUTPUT)ui/browsers/map.o
   LIB_OBJS += $(OUTPUT)ui/browsers/scripts.o
   LIB_OBJS += $(OUTPUT)ui/tui/setup.o
   LIB_OBJS += $(OUTPUT)ui/tui/util.o
   LIB_OBJS += $(OUTPUT)ui/tui/helpline.o
   LIB_OBJS += $(OUTPUT)ui/tui/progress.o
   LIB_H += ui/browser.h
   LIB_H += ui/browsers/map.h
   LIB_H += ui/keysyms.h
   LIB_H += ui/libslang.h
 endif
 ifndef NO_GTK2
   LIB_OBJS += $(OUTPUT)ui/gtk/browser.o
   LIB_OBJS += $(OUTPUT)ui/gtk/hists.o
   LIB_OBJS += $(OUTPUT)ui/gtk/setup.o
   LIB_OBJS += $(OUTPUT)ui/gtk/util.o
   LIB_OBJS += $(OUTPUT)ui/gtk/helpline.o
   LIB_OBJS += $(OUTPUT)ui/gtk/progress.o
   LIB_OBJS += $(OUTPUT)ui/gtk/annotate.o
 endif
 ifndef NO_LIBPERL
   LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-perl.o
   LIB_OBJS += $(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o
 endif
 ifndef NO_LIBPYTHON
   LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-python.o
   LIB_OBJS += $(OUTPUT)scripts/python/Perf-Trace-Util/Context.o
 endif
 ifeq ($(NO_PERF_REGS),0)
   ifeq ($(ARCH),x86)
     LIB_H += arch/x86/include/perf_regs.h
   endif
 endif
 ifndef NO_LIBNUMA
   BUILTIN_OBJS += $(OUTPUT)bench/numa.o
 endif
 ifdef ASCIIDOC8
   export ASCIIDOC8
 endif
 LIBS = -Wl,--whole-archive $(PERFLIBS) -Wl,--no-whole-archive -Wl,--start-group $(EXTLIBS) -Wl,--end-group
 export INSTALL SHELL_PATH
 ### Build rules
 SHELL = $(SHELL_PATH)
 all: shell_compatibility_test $(ALL_PROGRAMS) $(LANG_BINDINGS) $(OTHER_PROGRAMS)
 please_set_SHELL_PATH_to_a_more_modern_shell:
 	@$$(:)
 shell_compatibility_test: please_set_SHELL_PATH_to_a_more_modern_shell
 strip: $(PROGRAMS) $(OUTPUT)perf
 	$(STRIP) $(STRIP_OPTS) $(PROGRAMS) $(OUTPUT)perf
 $(OUTPUT)perf.o: perf.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -include $(OUTPUT)PERF-VERSION-FILE \
 		'-DPERF_HTML_PATH="$(htmldir_SQ)"' \
 		$(CFLAGS) -c $(filter %.c,$^) -o $@
 $(OUTPUT)perf: $(OUTPUT)perf.o $(BUILTIN_OBJS) $(PERFLIBS)
 	$(QUIET_LINK)$(CC) $(CFLAGS) $(LDFLAGS) $(OUTPUT)perf.o \
                $(BUILTIN_OBJS) $(LIBS) -o $@
 $(OUTPUT)builtin-help.o: builtin-help.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
 		'-DPERF_HTML_PATH="$(htmldir_SQ)"' \
 		'-DPERF_MAN_PATH="$(mandir_SQ)"' \
 		'-DPERF_INFO_PATH="$(infodir_SQ)"' $<
 $(OUTPUT)builtin-timechart.o: builtin-timechart.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
 		'-DPERF_HTML_PATH="$(htmldir_SQ)"' \
 		'-DPERF_MAN_PATH="$(mandir_SQ)"' \
 		'-DPERF_INFO_PATH="$(infodir_SQ)"' $<
 $(OUTPUT)common-cmds.h: util/generate-cmdlist.sh command-list.txt
 $(OUTPUT)common-cmds.h: $(wildcard Documentation/perf-*.txt)
 	$(QUIET_GEN). util/generate-cmdlist.sh > $@+ && mv $@+ $@
 $(SCRIPTS) : % : %.sh
 	$(QUIET_GEN)$(INSTALL) '$@.sh' '$(OUTPUT)$@'
 # These can record PERF_VERSION
 $(OUTPUT)perf.o perf.spec \
 	$(SCRIPTS) \
 	: $(OUTPUT)PERF-VERSION-FILE
 .SUFFIXES:
 .SUFFIXES: .o .c .S .s
 # These two need to be here so that when O= is not used they take precedence
 # over the general rule for .o
 $(OUTPUT)util/%-flex.o: $(OUTPUT)util/%-flex.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c -Iutil/ $(CFLAGS) -w $<
 $(OUTPUT)util/%-bison.o: $(OUTPUT)util/%-bison.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c -Iutil/ $(CFLAGS) -DYYENABLE_NLS=0 -DYYLTYPE_IS_TRIVIAL=0 -w $<
 $(OUTPUT)%.o: %.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $<
 $(OUTPUT)%.i: %.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -E $(CFLAGS) $<
 $(OUTPUT)%.s: %.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -S $(CFLAGS) $<
 $(OUTPUT)%.o: %.S
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $<
 $(OUTPUT)%.s: %.S
 	$(QUIET_CC)$(CC) -o $@ -E $(CFLAGS) $<
 $(OUTPUT)util/exec_cmd.o: util/exec_cmd.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
 		'-DPERF_EXEC_PATH="$(perfexecdir_SQ)"' \
 		'-DPREFIX="$(prefix_SQ)"' \
 		$<
 $(OUTPUT)tests/attr.o: tests/attr.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
 		'-DBINDIR="$(bindir_SQ)"' -DPYTHON='"$(PYTHON_WORD)"' \
 		$<
 $(OUTPUT)tests/python-use.o: tests/python-use.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) \
 		-DPYTHONPATH='"$(OUTPUT)python"' \
 		-DPYTHON='"$(PYTHON_WORD)"' \
 		$<
 $(OUTPUT)util/config.o: util/config.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 $(OUTPUT)ui/browser.o: ui/browser.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)ui/browsers/annotate.o: ui/browsers/annotate.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)ui/browsers/hists.o: ui/browsers/hists.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)ui/browsers/map.o: ui/browsers/map.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)ui/browsers/scripts.o: ui/browsers/scripts.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)util/rbtree.o: ../../lib/rbtree.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -Wno-unused-parameter -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 $(OUTPUT)util/parse-events.o: util/parse-events.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) -Wno-redundant-decls $<
 $(OUTPUT)util/scripting-engines/trace-event-perl.o: util/scripting-engines/trace-event-perl.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow -Wno-undef -Wno-switch-default $<
 $(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o: scripts/perl/Perf-Trace-Util/Context.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs -Wno-undef -Wno-switch-default $<
 $(OUTPUT)util/scripting-engines/trace-event-python.o: util/scripting-engines/trace-event-python.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
 $(OUTPUT)scripts/python/Perf-Trace-Util/Context.o: scripts/python/Perf-Trace-Util/Context.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
 $(OUTPUT)perf-%: %.o $(PERFLIBS)
 	$(QUIET_LINK)$(CC) $(CFLAGS) -o $@ $(LDFLAGS) $(filter %.o,$^) $(LIBS)
 $(LIB_OBJS) $(BUILTIN_OBJS): $(LIB_H)
 $(patsubst perf-%,%.o,$(PROGRAMS)): $(LIB_H) $(wildcard */*.h)
 # we compile into subdirectories. if the target directory is not the source directory, they might not exists. So
 # we depend the various files onto their directories.
 DIRECTORY_DEPS = $(LIB_OBJS) $(BUILTIN_OBJS) $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)common-cmds.h
 $(DIRECTORY_DEPS): | $(sort $(dir $(DIRECTORY_DEPS)))
 # In the second step, we make a rule to actually create these directories
 $(sort $(dir $(DIRECTORY_DEPS))):
 	$(QUIET_MKDIR)$(MKDIR) -p $@ 2>/dev/null
 $(LIB_FILE): $(LIB_OBJS)
 	$(QUIET_AR)$(RM) $@ && $(AR) rcs $@ $(LIB_OBJS)
 # libtraceevent.a
 $(LIBTRACEEVENT):
 	$(QUIET_SUBDIR0)$(TRACE_EVENT_DIR) $(QUIET_SUBDIR1) O=$(OUTPUT) libtraceevent.a
 $(LIBTRACEEVENT)-clean:
 	$(QUIET_SUBDIR0)$(TRACE_EVENT_DIR) $(QUIET_SUBDIR1) O=$(OUTPUT) clean
 # if subdir is set, we've been called from above so target has been built
 # already
 $(LIBLK):
 ifeq ($(subdir),)
 	$(QUIET_SUBDIR0)$(LK_DIR) $(QUIET_SUBDIR1) O=$(OUTPUT) liblk.a
 endif
 $(LIBLK)-clean:
 ifeq ($(subdir),)
 	$(QUIET_SUBDIR0)$(LK_DIR) $(QUIET_SUBDIR1) O=$(OUTPUT) clean
 endif
 help:
 	@echo 'Perf make targets:'
 	@echo '  doc		- make *all* documentation (see below)'
 	@echo '  man		- make manpage documentation (access with man <foo>)'
 	@echo '  html		- make html documentation'
 	@echo '  info		- make GNU info documentation (access with info <foo>)'
 	@echo '  pdf		- make pdf documentation'
 	@echo '  TAGS		- use etags to make tag information for source browsing'
 	@echo '  tags		- use ctags to make tag information for source browsing'
 	@echo '  cscope	- use cscope to make interactive browsing database'
 	@echo ''
 	@echo 'Perf install targets:'
 	@echo '  NOTE: documentation build requires asciidoc, xmlto packages to be installed'
 	@echo '  HINT: use "make prefix=<path> <install target>" to install to a particular'
 	@echo '        path like make prefix=/usr/local install install-doc'
 	@echo '  install	- install compiled binaries'
 	@echo '  install-doc	- install *all* documentation'
 	@echo '  install-man	- install manpage documentation'
 	@echo '  install-html	- install html documentation'
 	@echo '  install-info	- install GNU info documentation'
 	@echo '  install-pdf	- install pdf documentation'
 	@echo ''
 	@echo '  quick-install-doc	- alias for quick-install-man'
 	@echo '  quick-install-man	- install the documentation quickly'
 	@echo '  quick-install-html	- install the html documentation quickly'
 	@echo ''
 	@echo 'Perf maintainer targets:'
 	@echo '  clean			- clean all binary objects and build output'
 DOC_TARGETS := doc man html info pdf
 INSTALL_DOC_TARGETS := $(patsubst %,install-%,$(DOC_TARGETS)) try-install-man
 INSTALL_DOC_TARGETS += quick-install-doc quick-install-man quick-install-html
 # 'make doc' should call 'make -C Documentation all'
 $(DOC_TARGETS):
 	$(QUIET_SUBDIR0)Documentation $(QUIET_SUBDIR1) $(@:doc=all)
 TAGS:
 	$(RM) TAGS
 	$(FIND) . -name '*.[hcS]' -print | xargs etags -a
 tags:
 	$(RM) tags
 	$(FIND) . -name '*.[hcS]' -print | xargs ctags -a
 cscope:
 	$(RM) cscope*
 	$(FIND) . -name '*.[hcS]' -print | xargs cscope -b
 ### Detect prefix changes
 TRACK_CFLAGS = $(subst ','\'',$(CFLAGS)):\
              $(bindir_SQ):$(perfexecdir_SQ):$(template_dir_SQ):$(prefix_SQ)
 $(OUTPUT)PERF-CFLAGS: .FORCE-PERF-CFLAGS
 	@FLAGS='$(TRACK_CFLAGS)'; \
 	    if test x"$$FLAGS" != x"`cat $(OUTPUT)PERF-CFLAGS 2>/dev/null`" ; then \
 		echo 1>&2 "    * new build flags or prefix"; \
 		echo "$$FLAGS" >$(OUTPUT)PERF-CFLAGS; \
             fi
 ### Testing rules
 # GNU make supports exporting all variables by "export" without parameters.
 # However, the environment gets quite big, and some programs have problems
 # with that.
 check: $(OUTPUT)common-cmds.h
 	if sparse; \
 	then \
 		for i in *.c */*.c; \
 		do \
 			sparse $(CFLAGS) $(SPARSE_FLAGS) $$i || exit; \
 		done; \
 	else \
 		exit 1; \
 	fi
 ### Installation rules
 install-bin: all
 	$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(bindir_SQ)'
 	$(INSTALL) $(OUTPUT)perf '$(DESTDIR_SQ)$(bindir_SQ)'
 	$(INSTALL) $(OUTPUT)perf-archive -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
 ifndef NO_LIBPERL
 	$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/Perf-Trace-Util/lib/Perf/Trace'
 	$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/bin'
 	$(INSTALL) scripts/perl/Perf-Trace-Util/lib/Perf/Trace/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/Perf-Trace-Util/lib/Perf/Trace'
 	$(INSTALL) scripts/perl/*.pl -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl'
 	$(INSTALL) scripts/perl/bin/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/bin'
 endif
 ifndef NO_LIBPYTHON
 	$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/Perf-Trace-Util/lib/Perf/Trace'
 	$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/bin'
 	$(INSTALL) scripts/python/Perf-Trace-Util/lib/Perf/Trace/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/Perf-Trace-Util/lib/Perf/Trace'
 	$(INSTALL) scripts/python/*.py -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python'
 	$(INSTALL) scripts/python/bin/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/bin'
 endif
 	$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(sysconfdir_SQ)/bash_completion.d'
 	$(INSTALL) bash_completion '$(DESTDIR_SQ)$(sysconfdir_SQ)/bash_completion.d/perf'
 	$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/tests'
 	$(INSTALL) tests/attr.py '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/tests'
 	$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/tests/attr'
 	$(INSTALL) tests/attr/* '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/tests/attr'
 install: install-bin try-install-man
 install-python_ext:
 	$(PYTHON_WORD) util/setup.py --quiet install --root='/$(DESTDIR_SQ)'
 # 'make install-doc' should call 'make -C Documentation install'
 $(INSTALL_DOC_TARGETS):
 	$(QUIET_SUBDIR0)Documentation $(QUIET_SUBDIR1) $(@:-doc=)
 ### Cleaning rules
 clean: $(LIBTRACEEVENT)-clean $(LIBLK)-clean
 	$(RM) $(LIB_OBJS) $(BUILTIN_OBJS) $(LIB_FILE) $(OUTPUT)perf-archive $(OUTPUT)perf.o $(LANG_BINDINGS)
 	$(RM) $(ALL_PROGRAMS) perf
 	$(RM) *.spec *.pyc *.pyo */*.pyc */*.pyo $(OUTPUT)common-cmds.h TAGS tags cscope*
 	$(QUIET_SUBDIR0)Documentation $(QUIET_SUBDIR1) clean
 	$(RM) $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)PERF-CFLAGS
 	$(RM) $(OUTPUT)util/*-bison*
 	$(RM) $(OUTPUT)util/*-flex*
 	$(python-clean)
 .PHONY: all install clean strip $(LIBTRACEEVENT) $(LIBLK)
 .PHONY: shell_compatibility_test please_set_SHELL_PATH_to_a_more_modern_shell
 .PHONY: .FORCE-PERF-VERSION-FILE TAGS tags cscope .FORCE-PERF-CFLAGS

tools/perf/builtin-trace.c

Diff comments View file @ 72f4a11

 #include <traceevent/event-parse.h>
 #include "builtin.h"
 #include "util/color.h"
 #include "util/debug.h"
 #include "util/evlist.h"
 #include "util/machine.h"
 #include "util/session.h"
 #include "util/thread.h"
 #include "util/parse-options.h"
 #include "util/strlist.h"
 #include "util/intlist.h"
 #include "util/thread_map.h"
 #include <libaudit.h>
 #include <stdlib.h>
 #include <sys/mman.h>
 #include <linux/futex.h>
 static size_t syscall_arg__scnprintf_hex(char *bf, size_t size,
 					 unsigned long arg,
 					 u8 arg_idx __maybe_unused,
 					 u8 *arg_mask __maybe_unused)
 {
 	return scnprintf(bf, size, "%#lx", arg);
 }
 #define SCA_HEX syscall_arg__scnprintf_hex
 static size_t syscall_arg__scnprintf_whence(char *bf, size_t size,
 					    unsigned long arg,
 					    u8 arg_idx __maybe_unused,
 					    u8 *arg_mask __maybe_unused)
 {
 	int whence = arg;
 	switch (whence) {
 #define P_WHENCE(n) case SEEK_##n: return scnprintf(bf, size, #n)
 	P_WHENCE(SET);
 	P_WHENCE(CUR);
 	P_WHENCE(END);
 #ifdef SEEK_DATA
 	P_WHENCE(DATA);
 #endif
 #ifdef SEEK_HOLE
 	P_WHENCE(HOLE);
 #endif
 #undef P_WHENCE
 	default: break;
 	}
 	return scnprintf(bf, size, "%#x", whence);
 }
 #define SCA_WHENCE syscall_arg__scnprintf_whence
 static size_t syscall_arg__scnprintf_mmap_prot(char *bf, size_t size,
 					       unsigned long arg,
 					       u8 arg_idx __maybe_unused,
 					       u8 *arg_mask __maybe_unused)
 {
 	int printed = 0, prot = arg;
 	if (prot == PROT_NONE)
 		return scnprintf(bf, size, "NONE");
 #define	P_MMAP_PROT(n) \
 	if (prot & PROT_##n) { \
 		printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
 		prot &= ~PROT_##n; \
 	}
 	P_MMAP_PROT(EXEC);
 	P_MMAP_PROT(READ);
 	P_MMAP_PROT(WRITE);
 #ifdef PROT_SEM
 	P_MMAP_PROT(SEM);
 #endif
 	P_MMAP_PROT(GROWSDOWN);
 	P_MMAP_PROT(GROWSUP);
 #undef P_MMAP_PROT
 	if (prot)
 		printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", prot);
 	return printed;
 }
 #define SCA_MMAP_PROT syscall_arg__scnprintf_mmap_prot
 static size_t syscall_arg__scnprintf_mmap_flags(char *bf, size_t size,
 						unsigned long arg, u8 arg_idx __maybe_unused,
 						u8 *arg_mask __maybe_unused)
 {
 	int printed = 0, flags = arg;
 #define	P_MMAP_FLAG(n) \
 	if (flags & MAP_##n) { \
 		printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
 		flags &= ~MAP_##n; \
 	}
 	P_MMAP_FLAG(SHARED);
 	P_MMAP_FLAG(PRIVATE);
+#ifdef MAP_32BIT
 	P_MMAP_FLAG(32BIT);
+#endif
 	P_MMAP_FLAG(ANONYMOUS);
 	P_MMAP_FLAG(DENYWRITE);
 	P_MMAP_FLAG(EXECUTABLE);
 	P_MMAP_FLAG(FILE);
 	P_MMAP_FLAG(FIXED);
 	P_MMAP_FLAG(GROWSDOWN);
 #ifdef MAP_HUGETLB
 	P_MMAP_FLAG(HUGETLB);
 #endif
 	P_MMAP_FLAG(LOCKED);
 	P_MMAP_FLAG(NONBLOCK);
 	P_MMAP_FLAG(NORESERVE);
 	P_MMAP_FLAG(POPULATE);
 	P_MMAP_FLAG(STACK);
 #ifdef MAP_UNINITIALIZED
 	P_MMAP_FLAG(UNINITIALIZED);
 #endif
 #undef P_MMAP_FLAG
 	if (flags)
 		printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
 	return printed;
 }
 #define SCA_MMAP_FLAGS syscall_arg__scnprintf_mmap_flags
 static size_t syscall_arg__scnprintf_madvise_behavior(char *bf, size_t size,
 						      unsigned long arg, u8 arg_idx __maybe_unused,
 						      u8 *arg_mask __maybe_unused)
 {
 	int behavior = arg;
 	switch (behavior) {
 #define	P_MADV_BHV(n) case MADV_##n: return scnprintf(bf, size, #n)
 	P_MADV_BHV(NORMAL);
 	P_MADV_BHV(RANDOM);
 	P_MADV_BHV(SEQUENTIAL);
 	P_MADV_BHV(WILLNEED);
 	P_MADV_BHV(DONTNEED);
 	P_MADV_BHV(REMOVE);
 	P_MADV_BHV(DONTFORK);
 	P_MADV_BHV(DOFORK);
 	P_MADV_BHV(HWPOISON);
 #ifdef MADV_SOFT_OFFLINE
 	P_MADV_BHV(SOFT_OFFLINE);
 #endif
 	P_MADV_BHV(MERGEABLE);
 	P_MADV_BHV(UNMERGEABLE);
 #ifdef MADV_HUGEPAGE
 	P_MADV_BHV(HUGEPAGE);
 #endif
 #ifdef MADV_NOHUGEPAGE
 	P_MADV_BHV(NOHUGEPAGE);
 #endif
 #ifdef MADV_DONTDUMP
 	P_MADV_BHV(DONTDUMP);
 #endif
 #ifdef MADV_DODUMP
 	P_MADV_BHV(DODUMP);
 #endif
 #undef P_MADV_PHV
 	default: break;
 	}
 	return scnprintf(bf, size, "%#x", behavior);
 }
 #define SCA_MADV_BHV syscall_arg__scnprintf_madvise_behavior
 static size_t syscall_arg__scnprintf_futex_op(char *bf, size_t size, unsigned long arg,
 					      u8 arg_idx __maybe_unused, u8 *arg_mask)
 {
 	enum syscall_futex_args {
 		SCF_UADDR   = (1 << 0),
 		SCF_OP	    = (1 << 1),
 		SCF_VAL	    = (1 << 2),
 		SCF_TIMEOUT = (1 << 3),
 		SCF_UADDR2  = (1 << 4),
 		SCF_VAL3    = (1 << 5),
 	};
 	int op = arg;
 	int cmd = op & FUTEX_CMD_MASK;
 	size_t printed = 0;
 	switch (cmd) {
 #define	P_FUTEX_OP(n) case FUTEX_##n: printed = scnprintf(bf, size, #n);
 	P_FUTEX_OP(WAIT);	    *arg_mask |= SCF_VAL3|SCF_UADDR2;		  break;
 	P_FUTEX_OP(WAKE);	    *arg_mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
 	P_FUTEX_OP(FD);		    *arg_mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
 	P_FUTEX_OP(REQUEUE);	    *arg_mask |= SCF_VAL3|SCF_TIMEOUT;	          break;
 	P_FUTEX_OP(CMP_REQUEUE);    *arg_mask |= SCF_TIMEOUT;			  break;
 	P_FUTEX_OP(CMP_REQUEUE_PI); *arg_mask |= SCF_TIMEOUT;			  break;
 	P_FUTEX_OP(WAKE_OP);							  break;
 	P_FUTEX_OP(LOCK_PI);	    *arg_mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
 	P_FUTEX_OP(UNLOCK_PI);	    *arg_mask |= SCF_VAL3|SCF_UADDR2|SCF_TIMEOUT; break;
 	P_FUTEX_OP(TRYLOCK_PI);	    *arg_mask |= SCF_VAL3|SCF_UADDR2;		  break;
 	P_FUTEX_OP(WAIT_BITSET);    *arg_mask |= SCF_UADDR2;			  break;
 	P_FUTEX_OP(WAKE_BITSET);    *arg_mask |= SCF_UADDR2;			  break;
 	P_FUTEX_OP(WAIT_REQUEUE_PI);						  break;
 	default: printed = scnprintf(bf, size, "%#x", cmd);			  break;
 	}
 	if (op & FUTEX_PRIVATE_FLAG)
 		printed += scnprintf(bf + printed, size - printed, "|PRIV");
 	if (op & FUTEX_CLOCK_REALTIME)
 		printed += scnprintf(bf + printed, size - printed, "|CLKRT");
 	return printed;
 }
 #define SCA_FUTEX_OP  syscall_arg__scnprintf_futex_op
 static size_t syscall_arg__scnprintf_open_flags(char *bf, size_t size,
 					       unsigned long arg,
 					       u8 arg_idx, u8 *arg_mask)
 {
 	int printed = 0, flags = arg;
 	if (!(flags & O_CREAT))
 		*arg_mask |= 1 << (arg_idx + 1); /* Mask the mode parm */
 	if (flags == 0)
 		return scnprintf(bf, size, "RDONLY");
 #define	P_FLAG(n) \
 	if (flags & O_##n) { \
 		printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", #n); \
 		flags &= ~O_##n; \
 	}
 	P_FLAG(APPEND);
 	P_FLAG(ASYNC);
 	P_FLAG(CLOEXEC);
 	P_FLAG(CREAT);
 	P_FLAG(DIRECT);
 	P_FLAG(DIRECTORY);
 	P_FLAG(EXCL);
 	P_FLAG(LARGEFILE);
 	P_FLAG(NOATIME);
 	P_FLAG(NOCTTY);
 #ifdef O_NONBLOCK
 	P_FLAG(NONBLOCK);
 #elif O_NDELAY
 	P_FLAG(NDELAY);
 #endif
 #ifdef O_PATH
 	P_FLAG(PATH);
 #endif
 	P_FLAG(RDWR);
 #ifdef O_DSYNC
 	if ((flags & O_SYNC) == O_SYNC)
 		printed += scnprintf(bf + printed, size - printed, "%s%s", printed ? "|" : "", "SYNC");
 	else {
 		P_FLAG(DSYNC);
 	}
 #else
 	P_FLAG(SYNC);
 #endif
 	P_FLAG(TRUNC);
 	P_FLAG(WRONLY);
 #undef P_FLAG
 	if (flags)
 		printed += scnprintf(bf + printed, size - printed, "%s%#x", printed ? "|" : "", flags);
 	return printed;
 }
 #define SCA_OPEN_FLAGS syscall_arg__scnprintf_open_flags
 static struct syscall_fmt {
 	const char *name;
 	const char *alias;
 	size_t	   (*arg_scnprintf[6])(char *bf, size_t size, unsigned long arg, u8 arg_idx, u8 *arg_mask);
 	bool	   errmsg;
 	bool	   timeout;
 	bool	   hexret;
 } syscall_fmts[] = {
 	{ .name	    = "access",	    .errmsg = true, },
 	{ .name	    = "arch_prctl", .errmsg = true, .alias = "prctl", },
 	{ .name	    = "brk",	    .hexret = true,
 	  .arg_scnprintf = { [0] = SCA_HEX, /* brk */ }, },
 	{ .name	    = "mmap",	    .hexret = true, },
 	{ .name	    = "connect",    .errmsg = true, },
 	{ .name	    = "fstat",	    .errmsg = true, .alias = "newfstat", },
 	{ .name	    = "fstatat",    .errmsg = true, .alias = "newfstatat", },
 	{ .name	    = "futex",	    .errmsg = true,
 	  .arg_scnprintf = { [1] = SCA_FUTEX_OP, /* op */ }, },
 	{ .name	    = "ioctl",	    .errmsg = true,
 	  .arg_scnprintf = { [2] = SCA_HEX, /* arg */ }, },
 	{ .name	    = "lseek",	    .errmsg = true,
 	  .arg_scnprintf = { [2] = SCA_WHENCE, /* whence */ }, },
 	{ .name	    = "lstat",	    .errmsg = true, .alias = "newlstat", },
 	{ .name     = "madvise",    .errmsg = true,
 	  .arg_scnprintf = { [0] = SCA_HEX,	 /* start */
 			     [2] = SCA_MADV_BHV, /* behavior */ }, },
 	{ .name	    = "mmap",	    .hexret = true,
 	  .arg_scnprintf = { [0] = SCA_HEX,	  /* addr */
 			     [2] = SCA_MMAP_PROT, /* prot */
 			     [3] = SCA_MMAP_FLAGS, /* flags */ }, },
 	{ .name	    = "mprotect",   .errmsg = true,
 	  .arg_scnprintf = { [0] = SCA_HEX, /* start */
 			     [2] = SCA_MMAP_PROT, /* prot */ }, },
 	{ .name	    = "mremap",	    .hexret = true,
 	  .arg_scnprintf = { [0] = SCA_HEX, /* addr */
 			     [4] = SCA_HEX, /* new_addr */ }, },
 	{ .name	    = "munmap",	    .errmsg = true,
 	  .arg_scnprintf = { [0] = SCA_HEX, /* addr */ }, },
 	{ .name	    = "open",	    .errmsg = true,
 	  .arg_scnprintf = { [1] = SCA_OPEN_FLAGS, /* flags */ }, },
 	{ .name	    = "open_by_handle_at", .errmsg = true,
 	  .arg_scnprintf = { [2] = SCA_OPEN_FLAGS, /* flags */ }, },
 	{ .name	    = "openat",	    .errmsg = true,
 	  .arg_scnprintf = { [2] = SCA_OPEN_FLAGS, /* flags */ }, },
 	{ .name	    = "poll",	    .errmsg = true, .timeout = true, },
 	{ .name	    = "ppoll",	    .errmsg = true, .timeout = true, },
 	{ .name	    = "pread",	    .errmsg = true, .alias = "pread64", },
 	{ .name	    = "pwrite",	    .errmsg = true, .alias = "pwrite64", },
 	{ .name	    = "read",	    .errmsg = true, },
 	{ .name	    = "recvfrom",   .errmsg = true, },
 	{ .name	    = "select",	    .errmsg = true, .timeout = true, },
 	{ .name	    = "socket",	    .errmsg = true, },
 	{ .name	    = "stat",	    .errmsg = true, .alias = "newstat", },
 	{ .name	    = "uname",	    .errmsg = true, .alias = "newuname", },
 };
 static int syscall_fmt__cmp(const void *name, const void *fmtp)
 {
 	const struct syscall_fmt *fmt = fmtp;
 	return strcmp(name, fmt->name);
 }
 static struct syscall_fmt *syscall_fmt__find(const char *name)
 {
 	const int nmemb = ARRAY_SIZE(syscall_fmts);
 	return bsearch(name, syscall_fmts, nmemb, sizeof(struct syscall_fmt), syscall_fmt__cmp);
 }
 struct syscall {
 	struct event_format *tp_format;
 	const char	    *name;
 	bool		    filtered;
 	struct syscall_fmt  *fmt;
 	size_t		    (**arg_scnprintf)(char *bf, size_t size,
 					      unsigned long arg, u8 arg_idx, u8 *args_mask);
 };
 static size_t fprintf_duration(unsigned long t, FILE *fp)
 {
 	double duration = (double)t / NSEC_PER_MSEC;
 	size_t printed = fprintf(fp, "(");
 	if (duration >= 1.0)
 		printed += color_fprintf(fp, PERF_COLOR_RED, "%6.3f ms", duration);
 	else if (duration >= 0.01)
 		printed += color_fprintf(fp, PERF_COLOR_YELLOW, "%6.3f ms", duration);
 	else
 		printed += color_fprintf(fp, PERF_COLOR_NORMAL, "%6.3f ms", duration);
 	return printed + fprintf(fp, "): ");
 }
 struct thread_trace {
 	u64		  entry_time;
 	u64		  exit_time;
 	bool		  entry_pending;
 	unsigned long	  nr_events;
 	char		  *entry_str;
 	double		  runtime_ms;
 };
 static struct thread_trace *thread_trace__new(void)
 {
 	return zalloc(sizeof(struct thread_trace));
 }
 static struct thread_trace *thread__trace(struct thread *thread, FILE *fp)
 {
 	struct thread_trace *ttrace;
 	if (thread == NULL)
 		goto fail;
 	if (thread->priv == NULL)
 		thread->priv = thread_trace__new();
 	if (thread->priv == NULL)
 		goto fail;
 	ttrace = thread->priv;
 	++ttrace->nr_events;
 	return ttrace;
 fail:
 	color_fprintf(fp, PERF_COLOR_RED,
 		      "WARNING: not enough memory, dropping samples!\n");
 	return NULL;
 }
 struct trace {
 	struct perf_tool	tool;
 	int			audit_machine;
 	struct {
 		int		max;
 		struct syscall  *table;
 	} syscalls;
 	struct perf_record_opts opts;
 	struct machine		host;
 	u64			base_time;
 	FILE			*output;
 	unsigned long		nr_events;
 	struct strlist		*ev_qualifier;
 	bool			not_ev_qualifier;
 	struct intlist		*tid_list;
 	struct intlist		*pid_list;
 	bool			sched;
 	bool			multiple_threads;
 	double			duration_filter;
 	double			runtime_ms;
 };
 static bool trace__filter_duration(struct trace *trace, double t)
 {
 	return t < (trace->duration_filter * NSEC_PER_MSEC);
 }
 static size_t trace__fprintf_tstamp(struct trace *trace, u64 tstamp, FILE *fp)
 {
 	double ts = (double)(tstamp - trace->base_time) / NSEC_PER_MSEC;
 	return fprintf(fp, "%10.3f ", ts);
 }
 static bool done = false;
 static void sig_handler(int sig __maybe_unused)
 {
 	done = true;
 }
 static size_t trace__fprintf_entry_head(struct trace *trace, struct thread *thread,
 					u64 duration, u64 tstamp, FILE *fp)
 {
 	size_t printed = trace__fprintf_tstamp(trace, tstamp, fp);
 	printed += fprintf_duration(duration, fp);
 	if (trace->multiple_threads)
 		printed += fprintf(fp, "%d ", thread->tid);
 	return printed;
 }
 static int trace__process_event(struct trace *trace, struct machine *machine,
 				union perf_event *event)
 {
 	int ret = 0;
 	switch (event->header.type) {
 	case PERF_RECORD_LOST:
 		color_fprintf(trace->output, PERF_COLOR_RED,
 			      "LOST %" PRIu64 " events!\n", event->lost.lost);
 		ret = machine__process_lost_event(machine, event);
 	default:
 		ret = machine__process_event(machine, event);
 		break;
 	}
 	return ret;
 }
 static int trace__tool_process(struct perf_tool *tool,
 			       union perf_event *event,
 			       struct perf_sample *sample __maybe_unused,
 			       struct machine *machine)
 {
 	struct trace *trace = container_of(tool, struct trace, tool);
 	return trace__process_event(trace, machine, event);
 }
 static int trace__symbols_init(struct trace *trace, struct perf_evlist *evlist)
 {
 	int err = symbol__init();
 	if (err)
 		return err;
 	machine__init(&trace->host, "", HOST_KERNEL_ID);
 	machine__create_kernel_maps(&trace->host);
 	if (perf_target__has_task(&trace->opts.target)) {
 		err = perf_event__synthesize_thread_map(&trace->tool, evlist->threads,
 							trace__tool_process,
 							&trace->host);
 	} else {
 		err = perf_event__synthesize_threads(&trace->tool, trace__tool_process,
 						     &trace->host);
 	}
 	if (err)
 		symbol__exit();
 	return err;
 }
 static int syscall__set_arg_fmts(struct syscall *sc)
 {
 	struct format_field *field;
 	int idx = 0;
 	sc->arg_scnprintf = calloc(sc->tp_format->format.nr_fields - 1, sizeof(void *));
 	if (sc->arg_scnprintf == NULL)
 		return -1;
 	for (field = sc->tp_format->format.fields->next; field; field = field->next) {
 		if (sc->fmt && sc->fmt->arg_scnprintf[idx])
 			sc->arg_scnprintf[idx] = sc->fmt->arg_scnprintf[idx];
 		else if (field->flags & FIELD_IS_POINTER)
 			sc->arg_scnprintf[idx] = syscall_arg__scnprintf_hex;
 		++idx;
 	}
 	return 0;
 }
 static int trace__read_syscall_info(struct trace *trace, int id)
 {
 	char tp_name[128];
 	struct syscall *sc;
 	const char *name = audit_syscall_to_name(id, trace->audit_machine);
 	if (name == NULL)
 		return -1;
 	if (id > trace->syscalls.max) {
 		struct syscall *nsyscalls = realloc(trace->syscalls.table, (id + 1) * sizeof(*sc));
 		if (nsyscalls == NULL)
 			return -1;
 		if (trace->syscalls.max != -1) {
 			memset(nsyscalls + trace->syscalls.max + 1, 0,
 			       (id - trace->syscalls.max) * sizeof(*sc));
 		} else {
 			memset(nsyscalls, 0, (id + 1) * sizeof(*sc));
 		}
 		trace->syscalls.table = nsyscalls;
 		trace->syscalls.max   = id;
 	}
 	sc = trace->syscalls.table + id;
 	sc->name = name;
 	if (trace->ev_qualifier) {
 		bool in = strlist__find(trace->ev_qualifier, name) != NULL;
 		if (!(in ^ trace->not_ev_qualifier)) {
 			sc->filtered = true;
 			/*
 			 * No need to do read tracepoint information since this will be
 			 * filtered out.
 			 */
 			return 0;
 		}
 	}
 	sc->fmt  = syscall_fmt__find(sc->name);
 	snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
 	sc->tp_format = event_format__new("syscalls", tp_name);
 	if (sc->tp_format == NULL && sc->fmt && sc->fmt->alias) {
 		snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->fmt->alias);
 		sc->tp_format = event_format__new("syscalls", tp_name);
 	}
 	if (sc->tp_format == NULL)
 		return -1;
 	return syscall__set_arg_fmts(sc);
 }
 static size_t syscall__scnprintf_args(struct syscall *sc, char *bf, size_t size,
 				      unsigned long *args)
 {
 	int i = 0;
 	size_t printed = 0;
 	if (sc->tp_format != NULL) {
 		struct format_field *field;
 		u8 mask = 0, bit = 1;
 		for (field = sc->tp_format->format.fields->next; field;
 		     field = field->next, ++i, bit <<= 1) {
 			if (mask & bit)
 				continue;
 			printed += scnprintf(bf + printed, size - printed,
 					     "%s%s: ", printed ? ", " : "", field->name);
 			if (sc->arg_scnprintf && sc->arg_scnprintf[i]) {
 				printed += sc->arg_scnprintf[i](bf + printed, size - printed,
 								args[i], i, &mask);
 			} else {
 				printed += scnprintf(bf + printed, size - printed,
 						     "%ld", args[i]);
 			}
 		}
 	} else {
 		while (i < 6) {
 			printed += scnprintf(bf + printed, size - printed,
 					     "%sarg%d: %ld",
 					     printed ? ", " : "", i, args[i]);
 			++i;
 		}
 	}
 	return printed;
 }
 typedef int (*tracepoint_handler)(struct trace *trace, struct perf_evsel *evsel,
 				  struct perf_sample *sample);
 static struct syscall *trace__syscall_info(struct trace *trace,
 					   struct perf_evsel *evsel,
 					   struct perf_sample *sample)
 {
 	int id = perf_evsel__intval(evsel, sample, "id");
 	if (id < 0) {
 		/*
 		 * XXX: Noticed on x86_64, reproduced as far back as 3.0.36, haven't tried
 		 * before that, leaving at a higher verbosity level till that is
 		 * explained. Reproduced with plain ftrace with:
 		 *
 		 * echo 1 > /t/events/raw_syscalls/sys_exit/enable
 		 * grep "NR -1 " /t/trace_pipe
 		 *
 		 * After generating some load on the machine.
  		 */
 		if (verbose > 1) {
 			static u64 n;
 			fprintf(trace->output, "Invalid syscall %d id, skipping (%s, %" PRIu64 ") ...\n",
 				id, perf_evsel__name(evsel), ++n);
 		}
 		return NULL;
 	}
 	if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL) &&
 	    trace__read_syscall_info(trace, id))
 		goto out_cant_read;
 	if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL))
 		goto out_cant_read;
 	return &trace->syscalls.table[id];
 out_cant_read:
 	if (verbose) {
 		fprintf(trace->output, "Problems reading syscall %d", id);
 		if (id <= trace->syscalls.max && trace->syscalls.table[id].name != NULL)
 			fprintf(trace->output, "(%s)", trace->syscalls.table[id].name);
 		fputs(" information\n", trace->output);
 	}
 	return NULL;
 }
 static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
 			    struct perf_sample *sample)
 {
 	char *msg;
 	void *args;
 	size_t printed = 0;
 	struct thread *thread;
 	struct syscall *sc = trace__syscall_info(trace, evsel, sample);
 	struct thread_trace *ttrace;
 	if (sc == NULL)
 		return -1;
 	if (sc->filtered)
 		return 0;
 	thread = machine__findnew_thread(&trace->host, sample->pid,
 					 sample->tid);
 	ttrace = thread__trace(thread, trace->output);
 	if (ttrace == NULL)
 		return -1;
 	args = perf_evsel__rawptr(evsel, sample, "args");
 	if (args == NULL) {
 		fprintf(trace->output, "Problems reading syscall arguments\n");
 		return -1;
 	}
 	ttrace = thread->priv;
 	if (ttrace->entry_str == NULL) {
 		ttrace->entry_str = malloc(1024);
 		if (!ttrace->entry_str)
 			return -1;
 	}
 	ttrace->entry_time = sample->time;
 	msg = ttrace->entry_str;
 	printed += scnprintf(msg + printed, 1024 - printed, "%s(", sc->name);
 	printed += syscall__scnprintf_args(sc, msg + printed, 1024 - printed,  args);
 	if (!strcmp(sc->name, "exit_group") || !strcmp(sc->name, "exit")) {
 		if (!trace->duration_filter) {
 			trace__fprintf_entry_head(trace, thread, 1, sample->time, trace->output);
 			fprintf(trace->output, "%-70s\n", ttrace->entry_str);
 		}
 	} else
 		ttrace->entry_pending = true;
 	return 0;
 }
 static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
 			   struct perf_sample *sample)
 {
 	int ret;
 	u64 duration = 0;
 	struct thread *thread;
 	struct syscall *sc = trace__syscall_info(trace, evsel, sample);
 	struct thread_trace *ttrace;
 	if (sc == NULL)
 		return -1;
 	if (sc->filtered)
 		return 0;
 	thread = machine__findnew_thread(&trace->host, sample->pid,
 					 sample->tid);
 	ttrace = thread__trace(thread, trace->output);
 	if (ttrace == NULL)
 		return -1;
 	ret = perf_evsel__intval(evsel, sample, "ret");
 	ttrace = thread->priv;
 	ttrace->exit_time = sample->time;
 	if (ttrace->entry_time) {
 		duration = sample->time - ttrace->entry_time;
 		if (trace__filter_duration(trace, duration))
 			goto out;
 	} else if (trace->duration_filter)
 		goto out;
 	trace__fprintf_entry_head(trace, thread, duration, sample->time, trace->output);
 	if (ttrace->entry_pending) {
 		fprintf(trace->output, "%-70s", ttrace->entry_str);
 	} else {
 		fprintf(trace->output, " ... [");
 		color_fprintf(trace->output, PERF_COLOR_YELLOW, "continued");
 		fprintf(trace->output, "]: %s()", sc->name);
 	}
 	if (sc->fmt == NULL) {
 signed_print:
 		fprintf(trace->output, ") = %d", ret);
 	} else if (ret < 0 && sc->fmt->errmsg) {
 		char bf[256];
 		const char *emsg = strerror_r(-ret, bf, sizeof(bf)),
 			   *e = audit_errno_to_name(-ret);
 		fprintf(trace->output, ") = -1 %s %s", e, emsg);
 	} else if (ret == 0 && sc->fmt->timeout)
 		fprintf(trace->output, ") = 0 Timeout");
 	else if (sc->fmt->hexret)
 		fprintf(trace->output, ") = %#x", ret);
 	else
 		goto signed_print;
 	fputc('\n', trace->output);
 out:
 	ttrace->entry_pending = false;
 	return 0;
 }
 static int trace__sched_stat_runtime(struct trace *trace, struct perf_evsel *evsel,
 				     struct perf_sample *sample)
 {
         u64 runtime = perf_evsel__intval(evsel, sample, "runtime");
 	double runtime_ms = (double)runtime / NSEC_PER_MSEC;
 	struct thread *thread = machine__findnew_thread(&trace->host,
 							sample->pid,
 							sample->tid);
 	struct thread_trace *ttrace = thread__trace(thread, trace->output);
 	if (ttrace == NULL)
 		goto out_dump;
 	ttrace->runtime_ms += runtime_ms;
 	trace->runtime_ms += runtime_ms;
 	return 0;
 out_dump:
 	fprintf(trace->output, "%s: comm=%s,pid=%u,runtime=%" PRIu64 ",vruntime=%" PRIu64 ")\n",
 	       evsel->name,
 	       perf_evsel__strval(evsel, sample, "comm"),
 	       (pid_t)perf_evsel__intval(evsel, sample, "pid"),
 	       runtime,
 	       perf_evsel__intval(evsel, sample, "vruntime"));
 	return 0;
 }
 static bool skip_sample(struct trace *trace, struct perf_sample *sample)
 {
 	if ((trace->pid_list && intlist__find(trace->pid_list, sample->pid)) ||
 	    (trace->tid_list && intlist__find(trace->tid_list, sample->tid)))
 		return false;
 	if (trace->pid_list || trace->tid_list)
 		return true;
 	return false;
 }
 static int trace__process_sample(struct perf_tool *tool,
 				 union perf_event *event __maybe_unused,
 				 struct perf_sample *sample,
 				 struct perf_evsel *evsel,
 				 struct machine *machine __maybe_unused)
 {
 	struct trace *trace = container_of(tool, struct trace, tool);
 	int err = 0;
 	tracepoint_handler handler = evsel->handler.func;
 	if (skip_sample(trace, sample))
 		return 0;
 	if (trace->base_time == 0)
 		trace->base_time = sample->time;
 	if (handler)
 		handler(trace, evsel, sample);
 	return err;
 }
 static bool
 perf_session__has_tp(struct perf_session *session, const char *name)
 {
 	struct perf_evsel *evsel;
 	evsel = perf_evlist__find_tracepoint_by_name(session->evlist, name);
 	return evsel != NULL;
 }
 static int parse_target_str(struct trace *trace)
 {
 	if (trace->opts.target.pid) {
 		trace->pid_list = intlist__new(trace->opts.target.pid);
 		if (trace->pid_list == NULL) {
 			pr_err("Error parsing process id string\n");
 			return -EINVAL;
 		}
 	}
 	if (trace->opts.target.tid) {
 		trace->tid_list = intlist__new(trace->opts.target.tid);
 		if (trace->tid_list == NULL) {
 			pr_err("Error parsing thread id string\n");
 			return -EINVAL;
 		}
 	}
 	return 0;
 }
 static int trace__run(struct trace *trace, int argc, const char **argv)
 {
 	struct perf_evlist *evlist = perf_evlist__new();
 	struct perf_evsel *evsel;
 	int err = -1, i;
 	unsigned long before;
 	const bool forks = argc > 0;
 	if (evlist == NULL) {
 		fprintf(trace->output, "Not enough memory to run!\n");
 		goto out;
 	}
 	if (perf_evlist__add_newtp(evlist, "raw_syscalls", "sys_enter", trace__sys_enter) ||
 	    perf_evlist__add_newtp(evlist, "raw_syscalls", "sys_exit", trace__sys_exit)) {
 		fprintf(trace->output, "Couldn't read the raw_syscalls tracepoints information!\n");
 		goto out_delete_evlist;
 	}
 	if (trace->sched &&
 	    perf_evlist__add_newtp(evlist, "sched", "sched_stat_runtime",
 				   trace__sched_stat_runtime)) {
 		fprintf(trace->output, "Couldn't read the sched_stat_runtime tracepoint information!\n");
 		goto out_delete_evlist;
 	}
 	err = perf_evlist__create_maps(evlist, &trace->opts.target);
 	if (err < 0) {
 		fprintf(trace->output, "Problems parsing the target to trace, check your options!\n");
 		goto out_delete_evlist;
 	}
 	err = trace__symbols_init(trace, evlist);
 	if (err < 0) {
 		fprintf(trace->output, "Problems initializing symbol libraries!\n");
 		goto out_delete_maps;
 	}
 	perf_evlist__config(evlist, &trace->opts);
 	signal(SIGCHLD, sig_handler);
 	signal(SIGINT, sig_handler);
 	if (forks) {
 		err = perf_evlist__prepare_workload(evlist, &trace->opts.target,
 						    argv, false, false);
 		if (err < 0) {
 			fprintf(trace->output, "Couldn't run the workload!\n");
 			goto out_delete_maps;
 		}
 	}
 	err = perf_evlist__open(evlist);
 	if (err < 0) {
 		fprintf(trace->output, "Couldn't create the events: %s\n", strerror(errno));
 		goto out_delete_maps;
 	}
 	err = perf_evlist__mmap(evlist, UINT_MAX, false);
 	if (err < 0) {
 		fprintf(trace->output, "Couldn't mmap the events: %s\n", strerror(errno));
 		goto out_close_evlist;
 	}
 	perf_evlist__enable(evlist);
 	if (forks)
 		perf_evlist__start_workload(evlist);
 	trace->multiple_threads = evlist->threads->map[0] == -1 || evlist->threads->nr > 1;
 again:
 	before = trace->nr_events;
 	for (i = 0; i < evlist->nr_mmaps; i++) {
 		union perf_event *event;
 		while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
 			const u32 type = event->header.type;
 			tracepoint_handler handler;
 			struct perf_sample sample;
 			++trace->nr_events;
 			err = perf_evlist__parse_sample(evlist, event, &sample);
 			if (err) {
 				fprintf(trace->output, "Can't parse sample, err = %d, skipping...\n", err);
 				continue;
 			}
 			if (trace->base_time == 0)
 				trace->base_time = sample.time;
 			if (type != PERF_RECORD_SAMPLE) {
 				trace__process_event(trace, &trace->host, event);
 				continue;
 			}
 			evsel = perf_evlist__id2evsel(evlist, sample.id);
 			if (evsel == NULL) {
 				fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample.id);
 				continue;
 			}
 			if (sample.raw_data == NULL) {
 				fprintf(trace->output, "%s sample with no payload for tid: %d, cpu %d, raw_size=%d, skipping...\n",
 				       perf_evsel__name(evsel), sample.tid,
 				       sample.cpu, sample.raw_size);
 				continue;
 			}
 			handler = evsel->handler.func;
 			handler(trace, evsel, &sample);
+			if (done)
+				goto out_unmap_evlist;
 		}
 	}
 	if (trace->nr_events == before) {
 		if (done)
 			goto out_unmap_evlist;
 		poll(evlist->pollfd, evlist->nr_fds, -1);
 	}
 	if (done)
 		perf_evlist__disable(evlist);
 	goto again;
 out_unmap_evlist:
 	perf_evlist__munmap(evlist);
 out_close_evlist:
 	perf_evlist__close(evlist);
 out_delete_maps:
 	perf_evlist__delete_maps(evlist);
 out_delete_evlist:
 	perf_evlist__delete(evlist);
 out:
 	return err;
 }
 static int trace__replay(struct trace *trace)
 {
 	const struct perf_evsel_str_handler handlers[] = {
 		{ "raw_syscalls:sys_enter",  trace__sys_enter, },
 		{ "raw_syscalls:sys_exit",   trace__sys_exit, },
 	};
 	struct perf_session *session;
 	int err = -1;
 	trace->tool.sample	  = trace__process_sample;
 	trace->tool.mmap	  = perf_event__process_mmap;
 	trace->tool.comm	  = perf_event__process_comm;
 	trace->tool.exit	  = perf_event__process_exit;
 	trace->tool.fork	  = perf_event__process_fork;
 	trace->tool.attr	  = perf_event__process_attr;
 	trace->tool.tracing_data = perf_event__process_tracing_data;
 	trace->tool.build_id	  = perf_event__process_build_id;
 	trace->tool.ordered_samples = true;
 	trace->tool.ordering_requires_timestamps = true;
 	/* add tid to output */
 	trace->multiple_threads = true;
 	if (symbol__init() < 0)
 		return -1;
 	session = perf_session__new(input_name, O_RDONLY, 0, false,
 				    &trace->tool);
 	if (session == NULL)
 		return -ENOMEM;
 	err = perf_session__set_tracepoints_handlers(session, handlers);
 	if (err)
 		goto out;
 	if (!perf_session__has_tp(session, "raw_syscalls:sys_enter")) {
 		pr_err("Data file does not have raw_syscalls:sys_enter events\n");
 		goto out;
 	}
 	if (!perf_session__has_tp(session, "raw_syscalls:sys_exit")) {
 		pr_err("Data file does not have raw_syscalls:sys_exit events\n");
 		goto out;
 	}
 	err = parse_target_str(trace);
 	if (err != 0)
 		goto out;
 	setup_pager();
 	err = perf_session__process_events(session, &trace->tool);
 	if (err)
 		pr_err("Failed to process events, error %d", err);
 out:
 	perf_session__delete(session);
 	return err;
 }
 static size_t trace__fprintf_threads_header(FILE *fp)
 {
 	size_t printed;
 	printed  = fprintf(fp, "\n _____________________________________________________________________\n");
 	printed += fprintf(fp," __)    Summary of events    (__\n\n");
 	printed += fprintf(fp,"              [ task - pid ]     [ events ] [ ratio ]  [ runtime ]\n");
 	printed += fprintf(fp," _____________________________________________________________________\n\n");
 	return printed;
 }
 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
 {
 	size_t printed = trace__fprintf_threads_header(fp);
 	struct rb_node *nd;
 	for (nd = rb_first(&trace->host.threads); nd; nd = rb_next(nd)) {
 		struct thread *thread = rb_entry(nd, struct thread, rb_node);
 		struct thread_trace *ttrace = thread->priv;
 		const char *color;
 		double ratio;
 		if (ttrace == NULL)
 			continue;
 		ratio = (double)ttrace->nr_events / trace->nr_events * 100.0;
 		color = PERF_COLOR_NORMAL;
 		if (ratio > 50.0)
 			color = PERF_COLOR_RED;
 		else if (ratio > 25.0)
 			color = PERF_COLOR_GREEN;
 		else if (ratio > 5.0)
 			color = PERF_COLOR_YELLOW;
 		printed += color_fprintf(fp, color, "%20s", thread->comm);
 		printed += fprintf(fp, " - %-5d :%11lu   [", thread->tid, ttrace->nr_events);
 		printed += color_fprintf(fp, color, "%5.1f%%", ratio);
 		printed += fprintf(fp, " ] %10.3f ms\n", ttrace->runtime_ms);
 	}
 	return printed;
 }
 static int trace__set_duration(const struct option *opt, const char *str,
 			       int unset __maybe_unused)
 {
 	struct trace *trace = opt->value;
 	trace->duration_filter = atof(str);
 	return 0;
 }
 static int trace__open_output(struct trace *trace, const char *filename)
 {
 	struct stat st;
 	if (!stat(filename, &st) && st.st_size) {
 		char oldname[PATH_MAX];
 		scnprintf(oldname, sizeof(oldname), "%s.old", filename);
 		unlink(oldname);
 		rename(filename, oldname);
 	}
 	trace->output = fopen(filename, "w");
 	return trace->output == NULL ? -errno : 0;
 }
 int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
 {
 	const char * const trace_usage[] = {
 		"perf trace [<options>] [<command>]",
 		"perf trace [<options>] -- <command> [<options>]",
 		NULL
 	};
 	struct trace trace = {
 		.audit_machine = audit_detect_machine(),
 		.syscalls = {
 			. max = -1,
 		},
 		.opts = {
 			.target = {
 				.uid	   = UINT_MAX,
 				.uses_mmap = true,
 			},
 			.user_freq     = UINT_MAX,
 			.user_interval = ULLONG_MAX,
 			.no_delay      = true,
 			.mmap_pages    = 1024,
 		},
 		.output = stdout,
 	};
 	const char *output_name = NULL;
 	const char *ev_qualifier_str = NULL;
 	const struct option trace_options[] = {
 	OPT_STRING('e', "expr", &ev_qualifier_str, "expr",
 		    "list of events to trace"),
 	OPT_STRING('o', "output", &output_name, "file", "output file name"),
 	OPT_STRING('i', "input", &input_name, "file", "Analyze events in file"),
 	OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
 		    "trace events on existing process id"),
 	OPT_STRING('t', "tid", &trace.opts.target.tid, "tid",
 		    "trace events on existing thread id"),
 	OPT_BOOLEAN('a', "all-cpus", &trace.opts.target.system_wide,
 		    "system-wide collection from all CPUs"),
 	OPT_STRING('C', "cpu", &trace.opts.target.cpu_list, "cpu",
 		    "list of cpus to monitor"),
 	OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
 		    "child tasks do not inherit counters"),
 	OPT_UINTEGER('m', "mmap-pages", &trace.opts.mmap_pages,
 		     "number of mmap data pages"),
 	OPT_STRING('u', "uid", &trace.opts.target.uid_str, "user",
 		   "user to profile"),
 	OPT_CALLBACK(0, "duration", &trace, "float",
 		     "show only events with duration > N.M ms",
 		     trace__set_duration),
 	OPT_BOOLEAN(0, "sched", &trace.sched, "show blocking scheduler events"),
 	OPT_INCR('v', "verbose", &verbose, "be more verbose"),
 	OPT_END()
 	};
 	int err;
 	char bf[BUFSIZ];
 	argc = parse_options(argc, argv, trace_options, trace_usage, 0);
 	if (output_name != NULL) {
 		err = trace__open_output(&trace, output_name);
 		if (err < 0) {
 			perror("failed to create output file");
 			goto out;
 		}
 	}
 	if (ev_qualifier_str != NULL) {
 		const char *s = ev_qualifier_str;
 		trace.not_ev_qualifier = *s == '!';
 		if (trace.not_ev_qualifier)
 			++s;
 		trace.ev_qualifier = strlist__new(true, s);
 		if (trace.ev_qualifier == NULL) {
 			fputs("Not enough memory to parse event qualifier",
 			      trace.output);
 			err = -ENOMEM;
 			goto out_close;
 		}
 	}
 	err = perf_target__validate(&trace.opts.target);
 	if (err) {
 		perf_target__strerror(&trace.opts.target, err, bf, sizeof(bf));
 		fprintf(trace.output, "%s", bf);
 		goto out_close;
 	}
 	err = perf_target__parse_uid(&trace.opts.target);
 	if (err) {
 		perf_target__strerror(&trace.opts.target, err, bf, sizeof(bf));
 		fprintf(trace.output, "%s", bf);
 		goto out_close;
 	}
 	if (!argc && perf_target__none(&trace.opts.target))
 		trace.opts.target.system_wide = true;
 	if (input_name)
 		err = trace__replay(&trace);
 	else
 		err = trace__run(&trace, argc, argv);
 	if (trace.sched && !err)
 		trace__fprintf_thread_summary(&trace, trace.output);
 out_close:
 	if (output_name != NULL)
 		fclose(trace.output);
 out:
 	return err;
 }

tools/perf/tests/builtin-test.c

Diff comments View file @ 72f4a11

 /*
  * builtin-test.c
  *
  * Builtin regression testing command: ever growing number of sanity tests
  */
 #include "builtin.h"
 #include "intlist.h"
 #include "tests.h"
 #include "debug.h"
 #include "color.h"
 #include "parse-options.h"
 #include "symbol.h"
 static struct test {
 	const char *desc;
 	int (*func)(void);
 } tests[] = {
 	{
 		.desc = "vmlinux symtab matches kallsyms",
 		.func = test__vmlinux_matches_kallsyms,
 	},
 	{
 		.desc = "detect open syscall event",
 		.func = test__open_syscall_event,
 	},
 	{
 		.desc = "detect open syscall event on all cpus",
 		.func = test__open_syscall_event_on_all_cpus,
 	},
 	{
 		.desc = "read samples using the mmap interface",
 		.func = test__basic_mmap,
 	},
 	{
 		.desc = "parse events tests",
 		.func = test__parse_events,
 	},
 #if defined(__x86_64__) || defined(__i386__)
 	{
 		.desc = "x86 rdpmc test",
 		.func = test__rdpmc,
 	},
 #endif
 	{
 		.desc = "Validate PERF_RECORD_* events & perf_sample fields",
 		.func = test__PERF_RECORD,
 	},
 	{
 		.desc = "Test perf pmu format parsing",
 		.func = test__pmu,
 	},
 	{
 		.desc = "Test dso data interface",
 		.func = test__dso_data,
 	},
 	{
 		.desc = "roundtrip evsel->name check",
 		.func = test__perf_evsel__roundtrip_name_test,
 	},
 	{
 		.desc = "Check parsing of sched tracepoints fields",
 		.func = test__perf_evsel__tp_sched_test,
 	},
 	{
 		.desc = "Generate and check syscalls:sys_enter_open event fields",
 		.func = test__syscall_open_tp_fields,
 	},
 	{
 		.desc = "struct perf_event_attr setup",
 		.func = test__attr,
 	},
 	{
 		.desc = "Test matching and linking multiple hists",
 		.func = test__hists_link,
 	},
 	{
 		.desc = "Try 'use perf' in python, checking link problems",
 		.func = test__python_use,
 	},
 	{
 		.desc = "Test breakpoint overflow signal handler",
 		.func = test__bp_signal,
 	},
 	{
 		.desc = "Test breakpoint overflow sampling",
 		.func = test__bp_signal_overflow,
 	},
 	{
 		.desc = "Test number of exit event of a simple workload",
 		.func = test__task_exit,
 	},
 	{
 		.desc = "Test software clock events have valid period values",
 		.func = test__sw_clock_freq,
 	},
 #if defined(__x86_64__) || defined(__i386__)
 	{
 		.desc = "Test converting perf time to TSC",
 		.func = test__perf_time_to_tsc,
 	},
 #endif
 	{
 		.desc = "Test object code reading",
 		.func = test__code_reading,
 	},
 	{
 		.desc = "Test sample parsing",
 		.func = test__sample_parsing,
 	},
 	{
 		.desc = "Test using a dummy software event to keep tracking",
 		.func = test__keep_tracking,
 	},
 	{
+		.desc = "Test parsing with no sample_id_all bit set",
+		.func = test__parse_no_sample_id_all,
+	},
+	{
 		.func = NULL,
 	},
 };
 static bool perf_test__matches(int curr, int argc, const char *argv[])
 {
 	int i;
 	if (argc == 0)
 		return true;
 	for (i = 0; i < argc; ++i) {
 		char *end;
 		long nr = strtoul(argv[i], &end, 10);
 		if (*end == '\0') {
 			if (nr == curr + 1)
 				return true;
 			continue;
 		}
 		if (strstr(tests[curr].desc, argv[i]))
 			return true;
 	}
 	return false;
 }
 static int __cmd_test(int argc, const char *argv[], struct intlist *skiplist)
 {
 	int i = 0;
 	int width = 0;
 	while (tests[i].func) {
 		int len = strlen(tests[i].desc);
 		if (width < len)
 			width = len;
 		++i;
 	}
 	i = 0;
 	while (tests[i].func) {
 		int curr = i++, err;
 		if (!perf_test__matches(curr, argc, argv))
 			continue;
 		pr_info("%2d: %-*s:", i, width, tests[curr].desc);
 		if (intlist__find(skiplist, i)) {
 			color_fprintf(stderr, PERF_COLOR_YELLOW, " Skip (user override)\n");
 			continue;
 		}
 		pr_debug("\n--- start ---\n");
 		err = tests[curr].func();
 		pr_debug("---- end ----\n%s:", tests[curr].desc);
 		switch (err) {
 		case TEST_OK:
 			pr_info(" Ok\n");
 			break;
 		case TEST_SKIP:
 			color_fprintf(stderr, PERF_COLOR_YELLOW, " Skip\n");
 			break;
 		case TEST_FAIL:
 		default:
 			color_fprintf(stderr, PERF_COLOR_RED, " FAILED!\n");
 			break;
 		}
 	}
 	return 0;
 }
 static int perf_test__list(int argc, const char **argv)
 {
 	int i = 0;
 	while (tests[i].func) {
 		int curr = i++;
 		if (argc > 1 && !strstr(tests[curr].desc, argv[1]))
 			continue;
 		pr_info("%2d: %s\n", i, tests[curr].desc);
 	}
 	return 0;
 }
 int cmd_test(int argc, const char **argv, const char *prefix __maybe_unused)
 {
 	const char * const test_usage[] = {
 	"perf test [<options>] [{list <test-name-fragment>|[<test-name-fragments>|<test-numbers>]}]",
 	NULL,
 	};
 	const char *skip = NULL;
 	const struct option test_options[] = {
 	OPT_STRING('s', "skip", &skip, "tests", "tests to skip"),
 	OPT_INCR('v', "verbose", &verbose,
 		    "be more verbose (show symbol address, etc)"),
 	OPT_END()
 	};
 	struct intlist *skiplist = NULL;
 	argc = parse_options(argc, argv, test_options, test_usage, 0);
 	if (argc >= 1 && !strcmp(argv[0], "list"))
 		return perf_test__list(argc, argv);
 	symbol_conf.priv_size = sizeof(int);
 	symbol_conf.sort_by_name = true;
 	symbol_conf.try_vmlinux_path = true;
 	if (symbol__init() < 0)
 		return -1;
 	if (skip != NULL)
 		skiplist = intlist__new(skip);
 	return __cmd_test(argc, argv, skiplist);
 }

tools/perf/tests/parse-no-sample-id-all.c

Diff comments View file @ 72f4a11

File was created	1	#include <sys/types.h>
	2	#include <stddef.h>
	3
	4	#include "tests.h"
	5
	6	#include "event.h"
	7	#include "evlist.h"
	8	#include "header.h"
	9	#include "util.h"
	10
	11	static int process_event(struct perf_evlist *pevlist, union perf_event event)
	12	{
	13	struct perf_sample sample;
	14
	15	if (event->header.type == PERF_RECORD_HEADER_ATTR) {
	16	if (perf_event__process_attr(NULL, event, pevlist)) {
	17	pr_debug("perf_event__process_attr failed\n");
	18	return -1;
	19	}
	20	return 0;
	21	}
	22
	23	if (event->header.type >= PERF_RECORD_USER_TYPE_START)
	24	return -1;
	25
	26	if (!*pevlist)
	27	return -1;
	28
	29	if (perf_evlist__parse_sample(*pevlist, event, &sample)) {
	30	pr_debug("perf_evlist__parse_sample failed\n");
	31	return -1;
	32	}
	33
	34	return 0;
	35	}
	36
	37	static int process_events(union perf_event **events, size_t count)
	38	{
	39	struct perf_evlist *evlist = NULL;
	40	int err = 0;
	41	size_t i;
	42
	43	for (i = 0; i < count && !err; i++)
	44	err = process_event(&evlist, events[i]);
	45
	46	if (evlist)
	47	perf_evlist__delete(evlist);
	48
	49	return err;
	50	}
	51
	52	struct test_attr_event {
	53	struct attr_event attr;
	54	u64 id;
	55	};
	56
	57	/**
	58	* test__parse_no_sample_id_all - test parsing with no sample_id_all bit set.
	59	*
	60	* This function tests parsing data produced on kernel's that do not support the
	61	* sample_id_all bit. Without the sample_id_all bit, non-sample events (such as
	62	* mmap events) do not have an id sample appended, and consequently logic
	63	* designed to determine the id will not work. That case happens when there is
	64	* more than one selected event, so this test processes three events: 2
	65	* attributes representing the selected events and one mmap event.
	66	*
	67	* Return: %0 on success, %-1 if the test fails.
	68	*/
	69	int test__parse_no_sample_id_all(void)
	70	{
	71	int err;
	72
	73	struct test_attr_event event1 = {
	74	.attr = {
	75	.header = {
	76	.type = PERF_RECORD_HEADER_ATTR,
	77	.size = sizeof(struct test_attr_event),
	78	},
	79	},
	80	.id = 1,
	81	};
	82	struct test_attr_event event2 = {
	83	.attr = {
	84	.header = {
	85	.type = PERF_RECORD_HEADER_ATTR,
	86	.size = sizeof(struct test_attr_event),
	87	},
	88	},
	89	.id = 2,
	90	};
	91	struct mmap_event event3 = {
	92	.header = {
	93	.type = PERF_RECORD_MMAP,
	94	.size = sizeof(struct mmap_event),
	95	},
	96	};
	97	union perf_event *events[] = {
	98	(union perf_event *)&event1,
	99	(union perf_event *)&event2,
	100	(union perf_event *)&event3,
	101	};
	102
	103	err = process_events(events, ARRAY_SIZE(events));
	104	if (err)
	105	return -1;
	106
	107	return 0;
	108	}
	109

tools/perf/tests/tests.h

Diff comments View file @ 72f4a11

 #ifndef TESTS_H
 #define TESTS_H
 #define TEST_ASSERT_VAL(text, cond)					 \
 do {									 \
 	if (!(cond)) {							 \
 		pr_debug("FAILED %s:%d %s\n", __FILE__, __LINE__, text); \
 		return -1;						 \
 	}								 \
 } while (0)
 enum {
 	TEST_OK   =  0,
 	TEST_FAIL = -1,
 	TEST_SKIP = -2,
 };
 /* Tests */
 int test__vmlinux_matches_kallsyms(void);
 int test__open_syscall_event(void);
 int test__open_syscall_event_on_all_cpus(void);
 int test__basic_mmap(void);
 int test__PERF_RECORD(void);
 int test__rdpmc(void);
 int test__perf_evsel__roundtrip_name_test(void);
 int test__perf_evsel__tp_sched_test(void);
 int test__syscall_open_tp_fields(void);
 int test__pmu(void);
 int test__attr(void);
 int test__dso_data(void);
 int test__parse_events(void);
 int test__hists_link(void);
 int test__python_use(void);
 int test__bp_signal(void);
 int test__bp_signal_overflow(void);
 int test__task_exit(void);
 int test__sw_clock_freq(void);
 int test__perf_time_to_tsc(void);
 int test__code_reading(void);
 int test__sample_parsing(void);
 int test__keep_tracking(void);
+int test__parse_no_sample_id_all(void);
 #endif /* TESTS_H */

tools/perf/ui/stdio/hist.c

Diff comments View file @ 72f4a11

 #include <stdio.h>
 #include "../../util/util.h"
 #include "../../util/hist.h"
 #include "../../util/sort.h"
 #include "../../util/evsel.h"
 static size_t callchain__fprintf_left_margin(FILE *fp, int left_margin)
 {
 	int i;
 	int ret = fprintf(fp, "            ");
 	for (i = 0; i < left_margin; i++)
 		ret += fprintf(fp, " ");
 	return ret;
 }
 static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask,
 					  int left_margin)
 {
 	int i;
 	size_t ret = callchain__fprintf_left_margin(fp, left_margin);
 	for (i = 0; i < depth; i++)
 		if (depth_mask & (1 << i))
 			ret += fprintf(fp, "|          ");
 		else
 			ret += fprintf(fp, "           ");
 	ret += fprintf(fp, "\n");
 	return ret;
 }
 static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain,
 				     int depth, int depth_mask, int period,
 				     u64 total_samples, u64 hits,
 				     int left_margin)
 {
 	int i;
 	size_t ret = 0;
 	ret += callchain__fprintf_left_margin(fp, left_margin);
 	for (i = 0; i < depth; i++) {
 		if (depth_mask & (1 << i))
 			ret += fprintf(fp, "|");
 		else
 			ret += fprintf(fp, " ");
 		if (!period && i == depth - 1) {
 			double percent;
 			percent = hits * 100.0 / total_samples;
 			ret += percent_color_fprintf(fp, "--%2.2f%%-- ", percent);
 		} else
 			ret += fprintf(fp, "%s", "          ");
 	}
 	if (chain->ms.sym)
 		ret += fprintf(fp, "%s\n", chain->ms.sym->name);
 	else
 		ret += fprintf(fp, "0x%0" PRIx64 "\n", chain->ip);
 	return ret;
 }
 static struct symbol *rem_sq_bracket;
 static struct callchain_list rem_hits;
 static void init_rem_hits(void)
 {
 	rem_sq_bracket = malloc(sizeof(*rem_sq_bracket) + 6);
 	if (!rem_sq_bracket) {
 		fprintf(stderr, "Not enough memory to display remaining hits\n");
 		return;
 	}
 	strcpy(rem_sq_bracket->name, "[...]");
 	rem_hits.ms.sym = rem_sq_bracket;
 }
 static size_t __callchain__fprintf_graph(FILE *fp, struct rb_root *root,
 					 u64 total_samples, int depth,
 					 int depth_mask, int left_margin)
 {
 	struct rb_node *node, *next;
 	struct callchain_node *child;
 	struct callchain_list *chain;
 	int new_depth_mask = depth_mask;
 	u64 remaining;
 	size_t ret = 0;
 	int i;
 	uint entries_printed = 0;
 	remaining = total_samples;
 	node = rb_first(root);
 	while (node) {
 		u64 new_total;
 		u64 cumul;
 		child = rb_entry(node, struct callchain_node, rb_node);
 		cumul = callchain_cumul_hits(child);
 		remaining -= cumul;
 		/*
 		 * The depth mask manages the output of pipes that show
 		 * the depth. We don't want to keep the pipes of the current
 		 * level for the last child of this depth.
 		 * Except if we have remaining filtered hits. They will
 		 * supersede the last child
 		 */
 		next = rb_next(node);
 		if (!next && (callchain_param.mode != CHAIN_GRAPH_REL || !remaining))
 			new_depth_mask &= ~(1 << (depth - 1));
 		/*
 		 * But we keep the older depth mask for the line separator
 		 * to keep the level link until we reach the last child
 		 */
 		ret += ipchain__fprintf_graph_line(fp, depth, depth_mask,
 						   left_margin);
 		i = 0;
 		list_for_each_entry(chain, &child->val, list) {
 			ret += ipchain__fprintf_graph(fp, chain, depth,
 						      new_depth_mask, i++,
 						      total_samples,
 						      cumul,
 						      left_margin);
 		}
 		if (callchain_param.mode == CHAIN_GRAPH_REL)
 			new_total = child->children_hit;
 		else
 			new_total = total_samples;
 		ret += __callchain__fprintf_graph(fp, &child->rb_root, new_total,
 						  depth + 1,
 						  new_depth_mask | (1 << depth),
 						  left_margin);
 		node = next;
 		if (++entries_printed == callchain_param.print_limit)
 			break;
 	}
 	if (callchain_param.mode == CHAIN_GRAPH_REL &&
 		remaining && remaining != total_samples) {
 		if (!rem_sq_bracket)
 			return ret;
 		new_depth_mask &= ~(1 << (depth - 1));
 		ret += ipchain__fprintf_graph(fp, &rem_hits, depth,
 					      new_depth_mask, 0, total_samples,
 					      remaining, left_margin);
 	}
 	return ret;
 }
 static size_t callchain__fprintf_graph(FILE *fp, struct rb_root *root,
 				       u64 total_samples, int left_margin)
 {
 	struct callchain_node *cnode;
 	struct callchain_list *chain;
 	u32 entries_printed = 0;
 	bool printed = false;
 	struct rb_node *node;
 	int i = 0;
 	int ret = 0;
 	/*
 	 * If have one single callchain root, don't bother printing
 	 * its percentage (100 % in fractal mode and the same percentage
 	 * than the hist in graph mode). This also avoid one level of column.
 	 */
 	node = rb_first(root);
 	if (node && !rb_next(node)) {
 		cnode = rb_entry(node, struct callchain_node, rb_node);
 		list_for_each_entry(chain, &cnode->val, list) {
 			/*
 			 * If we sort by symbol, the first entry is the same than
 			 * the symbol. No need to print it otherwise it appears as
 			 * displayed twice.
 			 */
 			if (!i++ && sort__first_dimension == SORT_SYM)
 				continue;
 			if (!printed) {
 				ret += callchain__fprintf_left_margin(fp, left_margin);
 				ret += fprintf(fp, "|\n");
 				ret += callchain__fprintf_left_margin(fp, left_margin);
 				ret += fprintf(fp, "---");
 				left_margin += 3;
 				printed = true;
 			} else
 				ret += callchain__fprintf_left_margin(fp, left_margin);
 			if (chain->ms.sym)
 				ret += fprintf(fp, " %s\n", chain->ms.sym->name);
 			else
 				ret += fprintf(fp, " %p\n", (void *)(long)chain->ip);
 			if (++entries_printed == callchain_param.print_limit)
 				break;
 		}
 		root = &cnode->rb_root;
 	}
 	ret += __callchain__fprintf_graph(fp, root, total_samples,
 					  1, 1, left_margin);
 	ret += fprintf(fp, "\n");
 	return ret;
 }
 static size_t __callchain__fprintf_flat(FILE *fp,
 					struct callchain_node *self,
 					u64 total_samples)
 {
 	struct callchain_list *chain;
 	size_t ret = 0;
 	if (!self)
 		return 0;
 	ret += __callchain__fprintf_flat(fp, self->parent, total_samples);
 	list_for_each_entry(chain, &self->val, list) {
 		if (chain->ip >= PERF_CONTEXT_MAX)
 			continue;
 		if (chain->ms.sym)
 			ret += fprintf(fp, "                %s\n", chain->ms.sym->name);
 		else
 			ret += fprintf(fp, "                %p\n",
 					(void *)(long)chain->ip);
 	}
 	return ret;
 }
 static size_t callchain__fprintf_flat(FILE *fp, struct rb_root *self,
 				      u64 total_samples)
 {
 	size_t ret = 0;
 	u32 entries_printed = 0;
 	struct rb_node *rb_node;
 	struct callchain_node *chain;
 	rb_node = rb_first(self);
 	while (rb_node) {
 		double percent;
 		chain = rb_entry(rb_node, struct callchain_node, rb_node);
 		percent = chain->hit * 100.0 / total_samples;
 		ret = percent_color_fprintf(fp, "           %6.2f%%\n", percent);
 		ret += __callchain__fprintf_flat(fp, chain, total_samples);
 		ret += fprintf(fp, "\n");
 		if (++entries_printed == callchain_param.print_limit)
 			break;
 		rb_node = rb_next(rb_node);
 	}
 	return ret;
 }
 static size_t hist_entry_callchain__fprintf(struct hist_entry *he,
 					    u64 total_samples, int left_margin,
 					    FILE *fp)
 {
 	switch (callchain_param.mode) {
 	case CHAIN_GRAPH_REL:
 		return callchain__fprintf_graph(fp, &he->sorted_chain, he->stat.period,
 						left_margin);
 		break;
 	case CHAIN_GRAPH_ABS:
 		return callchain__fprintf_graph(fp, &he->sorted_chain, total_samples,
 						left_margin);
 		break;
 	case CHAIN_FLAT:
 		return callchain__fprintf_flat(fp, &he->sorted_chain, total_samples);
 		break;
 	case CHAIN_NONE:
 		break;
 	default:
 		pr_err("Bad callchain mode\n");
 	}
 	return 0;
 }
 static size_t hist_entry__callchain_fprintf(struct hist_entry *he,
 					    struct hists *hists,
 					    FILE *fp)
 {
 	int left_margin = 0;
 	u64 total_period = hists->stats.total_period;
 	if (sort__first_dimension == SORT_COMM) {
 		struct sort_entry *se = list_first_entry(&hist_entry__sort_list,
 							 typeof(*se), list);
 		left_margin = hists__col_len(hists, se->se_width_idx);
 		left_margin -= thread__comm_len(he->thread);
 	}
 	return hist_entry_callchain__fprintf(he, total_period, left_margin, fp);
 }
 static inline void advance_hpp(struct perf_hpp *hpp, int inc)
 {
 	hpp->buf  += inc;
 	hpp->size -= inc;
 }
 static int hist_entry__period_snprintf(struct perf_hpp *hpp,
 				       struct hist_entry *he,
 				       bool color)
 {
 	const char *sep = symbol_conf.field_sep;
 	struct perf_hpp_fmt *fmt;
 	char *start = hpp->buf;
 	int ret;
 	bool first = true;
 	if (symbol_conf.exclude_other && !he->parent)
 		return 0;
 	perf_hpp__for_each_format(fmt) {
 		/*
 		 * If there's no field_sep, we still need
 		 * to display initial '  '.
 		 */
 		if (!sep || !first) {
 			ret = scnprintf(hpp->buf, hpp->size, "%s", sep ?: "  ");
 			advance_hpp(hpp, ret);
 		} else
 			first = false;
 		if (color && fmt->color)
 			ret = fmt->color(fmt, hpp, he);
 		else
 			ret = fmt->entry(fmt, hpp, he);
 		advance_hpp(hpp, ret);
 	}
 	return hpp->buf - start;
 }
 static int hist_entry__fprintf(struct hist_entry *he, size_t size,
-			       struct hists *hists, FILE *fp)
+			       struct hists *hists,
+			       char *bf, size_t bfsz, FILE *fp)
 {
-	char bf[512];
 	int ret;
 	struct perf_hpp hpp = {
 		.buf		= bf,
 		.size		= size,
 	};
 	bool color = !symbol_conf.field_sep;
-	if (size == 0 || size > sizeof(bf))
+	if (size == 0 || size > bfsz)
-		size = hpp.size = sizeof(bf);
+		size = hpp.size = bfsz;
 	ret = hist_entry__period_snprintf(&hpp, he, color);
 	hist_entry__sort_snprintf(he, bf + ret, size - ret, hists);
 	ret = fprintf(fp, "%s\n", bf);
 	if (symbol_conf.use_callchain)
 		ret += hist_entry__callchain_fprintf(he, hists, fp);
 	return ret;
 }
 size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
 		      int max_cols, float min_pcnt, FILE *fp)
 {
 	struct perf_hpp_fmt *fmt;
 	struct sort_entry *se;
 	struct rb_node *nd;
 	size_t ret = 0;
 	unsigned int width;
 	const char *sep = symbol_conf.field_sep;
 	const char *col_width = symbol_conf.col_width_list_str;
 	int nr_rows = 0;
 	char bf[96];
 	struct perf_hpp dummy_hpp = {
 		.buf	= bf,
 		.size	= sizeof(bf),
 		.ptr	= hists_to_evsel(hists),
 	};
 	bool first = true;
+	size_t linesz;
+	char *line = NULL;
 	init_rem_hits();
 	if (!show_header)
 		goto print_entries;
 	fprintf(fp, "# ");
 	perf_hpp__for_each_format(fmt) {
 		if (!first)
 			fprintf(fp, "%s", sep ?: "  ");
 		else
 			first = false;
 		fmt->header(fmt, &dummy_hpp);
 		fprintf(fp, "%s", bf);
 	}
 	list_for_each_entry(se, &hist_entry__sort_list, list) {
 		if (se->elide)
 			continue;
 		if (sep) {
 			fprintf(fp, "%c%s", *sep, se->se_header);
 			continue;
 		}
 		width = strlen(se->se_header);
 		if (symbol_conf.col_width_list_str) {
 			if (col_width) {
 				hists__set_col_len(hists, se->se_width_idx,
 						   atoi(col_width));
 				col_width = strchr(col_width, ',');
 				if (col_width)
 					++col_width;
 			}
 		}
 		if (!hists__new_col_len(hists, se->se_width_idx, width))
 			width = hists__col_len(hists, se->se_width_idx);
 		fprintf(fp, "  %*s", width, se->se_header);
 	}
 	fprintf(fp, "\n");
 	if (max_rows && ++nr_rows >= max_rows)
 		goto out;
 	if (sep)
 		goto print_entries;
 	first = true;
 	fprintf(fp, "# ");
 	perf_hpp__for_each_format(fmt) {
 		unsigned int i;
 		if (!first)
 			fprintf(fp, "%s", sep ?: "  ");
 		else
 			first = false;
 		width = fmt->width(fmt, &dummy_hpp);
 		for (i = 0; i < width; i++)
 			fprintf(fp, ".");
 	}
 	list_for_each_entry(se, &hist_entry__sort_list, list) {
 		unsigned int i;
 		if (se->elide)
 			continue;
 		fprintf(fp, "  ");
 		width = hists__col_len(hists, se->se_width_idx);
 		if (width == 0)
 			width = strlen(se->se_header);
 		for (i = 0; i < width; i++)
 			fprintf(fp, ".");
 	}
 	fprintf(fp, "\n");
 	if (max_rows && ++nr_rows >= max_rows)
 		goto out;
 	fprintf(fp, "#\n");
 	if (max_rows && ++nr_rows >= max_rows)
 		goto out;
 print_entries:
+	linesz = hists__sort_list_width(hists) + 3 + 1;
+	line = malloc(linesz);
+	if (line == NULL) {
+		ret = -1;
+		goto out;
+	}
 	for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
 		struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 		float percent = h->stat.period * 100.0 /
 					hists->stats.total_period;
 		if (h->filtered)
 			continue;
 		if (percent < min_pcnt)
 			continue;
-		ret += hist_entry__fprintf(h, max_cols, hists, fp);
+		ret += hist_entry__fprintf(h, max_cols, hists, line, linesz, fp);
 		if (max_rows && ++nr_rows >= max_rows)
-			goto out;
+			break;
 		if (h->ms.map == NULL && verbose > 1) {
 			__map_groups__fprintf_maps(&h->thread->mg,
 						   MAP__FUNCTION, verbose, fp);
 			fprintf(fp, "%.10s end\n", graph_dotted_line);
 		}
 	}
+	free(line);
 out:
 	free(rem_sq_bracket);
 	return ret;
 }
 size_t events_stats__fprintf(struct events_stats *stats, FILE *fp)
 {
 	int i;
 	size_t ret = 0;
 	for (i = 0; i < PERF_RECORD_HEADER_MAX; ++i) {
 		const char *name;
 		if (stats->nr_events[i] == 0)
 			continue;
 		name = perf_event__name(i);
 		if (!strcmp(name, "UNKNOWN"))
 			continue;
 		ret += fprintf(fp, "%16s events: %10d\n", name,
 			       stats->nr_events[i]);
 	}
 	return ret;
 }

tools/perf/util/evlist.c

Diff comments View file @ 72f4a11

 /*
  * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
  *
  * Parts came from builtin-{top,stat,record}.c, see those files for further
  * copyright notes.
  *
  * Released under the GPL v2. (and only v2, not any later version)
  */
 #include "util.h"
 #include <lk/debugfs.h>
 #include <poll.h>
 #include "cpumap.h"
 #include "thread_map.h"
 #include "target.h"
 #include "evlist.h"
 #include "evsel.h"
 #include "debug.h"
 #include <unistd.h>
 #include "parse-events.h"
 #include <sys/mman.h>
 #include <linux/bitops.h>
 #include <linux/hash.h>
 #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
 #define SID(e, x, y) xyarray__entry(e->sample_id, x, y)
 void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus,
 		       struct thread_map *threads)
 {
 	int i;
 	for (i = 0; i < PERF_EVLIST__HLIST_SIZE; ++i)
 		INIT_HLIST_HEAD(&evlist->heads[i]);
 	INIT_LIST_HEAD(&evlist->entries);
 	perf_evlist__set_maps(evlist, cpus, threads);
 	evlist->workload.pid = -1;
 }
 struct perf_evlist *perf_evlist__new(void)
 {
 	struct perf_evlist *evlist = zalloc(sizeof(*evlist));
 	if (evlist != NULL)
 		perf_evlist__init(evlist, NULL, NULL);
 	return evlist;
 }
 /**
  * perf_evlist__set_id_pos - set the positions of event ids.
  * @evlist: selected event list
  *
  * Events with compatible sample types all have the same id_pos
  * and is_pos.  For convenience, put a copy on evlist.
  */
 void perf_evlist__set_id_pos(struct perf_evlist *evlist)
 {
 	struct perf_evsel *first = perf_evlist__first(evlist);
 	evlist->id_pos = first->id_pos;
 	evlist->is_pos = first->is_pos;
 }
 static void perf_evlist__purge(struct perf_evlist *evlist)
 {
 	struct perf_evsel *pos, *n;
 	list_for_each_entry_safe(pos, n, &evlist->entries, node) {
 		list_del_init(&pos->node);
 		perf_evsel__delete(pos);
 	}
 	evlist->nr_entries = 0;
 }
 void perf_evlist__exit(struct perf_evlist *evlist)
 {
 	free(evlist->mmap);
 	free(evlist->pollfd);
 	evlist->mmap = NULL;
 	evlist->pollfd = NULL;
 }
 void perf_evlist__delete(struct perf_evlist *evlist)
 {
 	perf_evlist__purge(evlist);
 	perf_evlist__exit(evlist);
 	free(evlist);
 }
 void perf_evlist__add(struct perf_evlist *evlist, struct perf_evsel *entry)
 {
 	list_add_tail(&entry->node, &evlist->entries);
 	if (!evlist->nr_entries++)
 		perf_evlist__set_id_pos(evlist);
 }
 void perf_evlist__splice_list_tail(struct perf_evlist *evlist,
 				   struct list_head *list,
 				   int nr_entries)
 {
 	bool set_id_pos = !evlist->nr_entries;
 	list_splice_tail(list, &evlist->entries);
 	evlist->nr_entries += nr_entries;
 	if (set_id_pos)
 		perf_evlist__set_id_pos(evlist);
 }
 void __perf_evlist__set_leader(struct list_head *list)
 {
 	struct perf_evsel *evsel, *leader;
 	leader = list_entry(list->next, struct perf_evsel, node);
 	evsel = list_entry(list->prev, struct perf_evsel, node);
 	leader->nr_members = evsel->idx - leader->idx + 1;
 	list_for_each_entry(evsel, list, node) {
 		evsel->leader = leader;
 	}
 }
 void perf_evlist__set_leader(struct perf_evlist *evlist)
 {
 	if (evlist->nr_entries) {
 		evlist->nr_groups = evlist->nr_entries > 1 ? 1 : 0;
 		__perf_evlist__set_leader(&evlist->entries);
 	}
 }
 int perf_evlist__add_default(struct perf_evlist *evlist)
 {
 	struct perf_event_attr attr = {
 		.type = PERF_TYPE_HARDWARE,
 		.config = PERF_COUNT_HW_CPU_CYCLES,
 	};
 	struct perf_evsel *evsel;
 	event_attr_init(&attr);
 	evsel = perf_evsel__new(&attr, 0);
 	if (evsel == NULL)
 		goto error;
 	/* use strdup() because free(evsel) assumes name is allocated */
 	evsel->name = strdup("cycles");
 	if (!evsel->name)
 		goto error_free;
 	perf_evlist__add(evlist, evsel);
 	return 0;
 error_free:
 	perf_evsel__delete(evsel);
 error:
 	return -ENOMEM;
 }
 static int perf_evlist__add_attrs(struct perf_evlist *evlist,
 				  struct perf_event_attr *attrs, size_t nr_attrs)
 {
 	struct perf_evsel *evsel, *n;
 	LIST_HEAD(head);
 	size_t i;
 	for (i = 0; i < nr_attrs; i++) {
 		evsel = perf_evsel__new(attrs + i, evlist->nr_entries + i);
 		if (evsel == NULL)
 			goto out_delete_partial_list;
 		list_add_tail(&evsel->node, &head);
 	}
 	perf_evlist__splice_list_tail(evlist, &head, nr_attrs);
 	return 0;
 out_delete_partial_list:
 	list_for_each_entry_safe(evsel, n, &head, node)
 		perf_evsel__delete(evsel);
 	return -1;
 }
 int __perf_evlist__add_default_attrs(struct perf_evlist *evlist,
 				     struct perf_event_attr *attrs, size_t nr_attrs)
 {
 	size_t i;
 	for (i = 0; i < nr_attrs; i++)
 		event_attr_init(attrs + i);
 	return perf_evlist__add_attrs(evlist, attrs, nr_attrs);
 }
 struct perf_evsel *
 perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id)
 {
 	struct perf_evsel *evsel;
 	list_for_each_entry(evsel, &evlist->entries, node) {
 		if (evsel->attr.type   == PERF_TYPE_TRACEPOINT &&
 		    (int)evsel->attr.config == id)
 			return evsel;
 	}
 	return NULL;
 }
 struct perf_evsel *
 perf_evlist__find_tracepoint_by_name(struct perf_evlist *evlist,
 				     const char *name)
 {
 	struct perf_evsel *evsel;
 	list_for_each_entry(evsel, &evlist->entries, node) {
 		if ((evsel->attr.type == PERF_TYPE_TRACEPOINT) &&
 		    (strcmp(evsel->name, name) == 0))
 			return evsel;
 	}
 	return NULL;
 }
 int perf_evlist__add_newtp(struct perf_evlist *evlist,
 			   const char *sys, const char *name, void *handler)
 {
 	struct perf_evsel *evsel;
 	evsel = perf_evsel__newtp(sys, name, evlist->nr_entries);
 	if (evsel == NULL)
 		return -1;
 	evsel->handler.func = handler;
 	perf_evlist__add(evlist, evsel);
 	return 0;
 }
 void perf_evlist__disable(struct perf_evlist *evlist)
 {
 	int cpu, thread;
 	struct perf_evsel *pos;
 	int nr_cpus = cpu_map__nr(evlist->cpus);
 	int nr_threads = thread_map__nr(evlist->threads);
 	for (cpu = 0; cpu < nr_cpus; cpu++) {
 		list_for_each_entry(pos, &evlist->entries, node) {
 			if (!perf_evsel__is_group_leader(pos) || !pos->fd)
 				continue;
 			for (thread = 0; thread < nr_threads; thread++)
 				ioctl(FD(pos, cpu, thread),
 				      PERF_EVENT_IOC_DISABLE, 0);
 		}
 	}
 }
 void perf_evlist__enable(struct perf_evlist *evlist)
 {
 	int cpu, thread;
 	struct perf_evsel *pos;
 	int nr_cpus = cpu_map__nr(evlist->cpus);
 	int nr_threads = thread_map__nr(evlist->threads);
 	for (cpu = 0; cpu < nr_cpus; cpu++) {
 		list_for_each_entry(pos, &evlist->entries, node) {
 			if (!perf_evsel__is_group_leader(pos) || !pos->fd)
 				continue;
 			for (thread = 0; thread < nr_threads; thread++)
 				ioctl(FD(pos, cpu, thread),
 				      PERF_EVENT_IOC_ENABLE, 0);
 		}
 	}
 }
 int perf_evlist__disable_event(struct perf_evlist *evlist,
 			       struct perf_evsel *evsel)
 {
 	int cpu, thread, err;
 	if (!evsel->fd)
 		return 0;
 	for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
 		for (thread = 0; thread < evlist->threads->nr; thread++) {
 			err = ioctl(FD(evsel, cpu, thread),
 				    PERF_EVENT_IOC_DISABLE, 0);
 			if (err)
 				return err;
 		}
 	}
 	return 0;
 }
 int perf_evlist__enable_event(struct perf_evlist *evlist,
 			      struct perf_evsel *evsel)
 {
 	int cpu, thread, err;
 	if (!evsel->fd)
 		return -EINVAL;
 	for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
 		for (thread = 0; thread < evlist->threads->nr; thread++) {
 			err = ioctl(FD(evsel, cpu, thread),
 				    PERF_EVENT_IOC_ENABLE, 0);
 			if (err)
 				return err;
 		}
 	}
 	return 0;
 }
 static int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
 {
 	int nr_cpus = cpu_map__nr(evlist->cpus);
 	int nr_threads = thread_map__nr(evlist->threads);
 	int nfds = nr_cpus * nr_threads * evlist->nr_entries;
 	evlist->pollfd = malloc(sizeof(struct pollfd) * nfds);
 	return evlist->pollfd != NULL ? 0 : -ENOMEM;
 }
 void perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd)
 {
 	fcntl(fd, F_SETFL, O_NONBLOCK);
 	evlist->pollfd[evlist->nr_fds].fd = fd;
 	evlist->pollfd[evlist->nr_fds].events = POLLIN;
 	evlist->nr_fds++;
 }
 static void perf_evlist__id_hash(struct perf_evlist *evlist,
 				 struct perf_evsel *evsel,
 				 int cpu, int thread, u64 id)
 {
 	int hash;
 	struct perf_sample_id *sid = SID(evsel, cpu, thread);
 	sid->id = id;
 	sid->evsel = evsel;
 	hash = hash_64(sid->id, PERF_EVLIST__HLIST_BITS);
 	hlist_add_head(&sid->node, &evlist->heads[hash]);
 }
 void perf_evlist__id_add(struct perf_evlist *evlist, struct perf_evsel *evsel,
 			 int cpu, int thread, u64 id)
 {
 	perf_evlist__id_hash(evlist, evsel, cpu, thread, id);
 	evsel->id[evsel->ids++] = id;
 }
 static int perf_evlist__id_add_fd(struct perf_evlist *evlist,
 				  struct perf_evsel *evsel,
 				  int cpu, int thread, int fd)
 {
 	u64 read_data[4] = { 0, };
 	int id_idx = 1; /* The first entry is the counter value */
 	u64 id;
 	int ret;
 	ret = ioctl(fd, PERF_EVENT_IOC_ID, &id);
 	if (!ret)
 		goto add;
 	if (errno != ENOTTY)
 		return -1;
 	/* Legacy way to get event id.. All hail to old kernels! */
 	/*
 	 * This way does not work with group format read, so bail
 	 * out in that case.
 	 */
 	if (perf_evlist__read_format(evlist) & PERF_FORMAT_GROUP)
 		return -1;
 	if (!(evsel->attr.read_format & PERF_FORMAT_ID) ||
 	    read(fd, &read_data, sizeof(read_data)) == -1)
 		return -1;
 	if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
 		++id_idx;
 	if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
 		++id_idx;
 	id = read_data[id_idx];
  add:
 	perf_evlist__id_add(evlist, evsel, cpu, thread, id);
 	return 0;
 }
 struct perf_sample_id *perf_evlist__id2sid(struct perf_evlist *evlist, u64 id)
 {
 	struct hlist_head *head;
 	struct perf_sample_id *sid;
 	int hash;
 	hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
 	head = &evlist->heads[hash];
 	hlist_for_each_entry(sid, head, node)
 		if (sid->id == id)
 			return sid;
 	return NULL;
 }
 struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id)
 {
 	struct perf_sample_id *sid;
 	if (evlist->nr_entries == 1)
 		return perf_evlist__first(evlist);
 	sid = perf_evlist__id2sid(evlist, id);
 	if (sid)
 		return sid->evsel;
 	if (!perf_evlist__sample_id_all(evlist))
 		return perf_evlist__first(evlist);
 	return NULL;
 }
 static int perf_evlist__event2id(struct perf_evlist *evlist,
 				 union perf_event *event, u64 *id)
 {
 	const u64 *array = event->sample.array;
 	ssize_t n;
 	n = (event->header.size - sizeof(event->header)) >> 3;
 	if (event->header.type == PERF_RECORD_SAMPLE) {
 		if (evlist->id_pos >= n)
 			return -1;
 		*id = array[evlist->id_pos];
 	} else {
 		if (evlist->is_pos > n)
 			return -1;
 		n -= evlist->is_pos;
 		*id = array[n];
 	}
 	return 0;
 }
 static struct perf_evsel *perf_evlist__event2evsel(struct perf_evlist *evlist,
 						   union perf_event *event)
 {
+	struct perf_evsel *first = perf_evlist__first(evlist);
 	struct hlist_head *head;
 	struct perf_sample_id *sid;
 	int hash;
 	u64 id;
 	if (evlist->nr_entries == 1)
-		return perf_evlist__first(evlist);
+		return first;
+	if (!first->attr.sample_id_all &&
+	    event->header.type != PERF_RECORD_SAMPLE)
+		return first;
 	if (perf_evlist__event2id(evlist, event, &id))
 		return NULL;
 	/* Synthesized events have an id of zero */
 	if (!id)
-		return perf_evlist__first(evlist);
+		return first;
 	hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
 	head = &evlist->heads[hash];
 	hlist_for_each_entry(sid, head, node) {
 		if (sid->id == id)
 			return sid->evsel;
 	}
 	return NULL;
 }
 union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
 {
 	struct perf_mmap *md = &evlist->mmap[idx];
 	unsigned int head = perf_mmap__read_head(md);
 	unsigned int old = md->prev;
 	unsigned char *data = md->base + page_size;
 	union perf_event *event = NULL;
 	if (evlist->overwrite) {
 		/*
 		 * If we're further behind than half the buffer, there's a chance
 		 * the writer will bite our tail and mess up the samples under us.
 		 *
 		 * If we somehow ended up ahead of the head, we got messed up.
 		 *
 		 * In either case, truncate and restart at head.
 		 */
 		int diff = head - old;
 		if (diff > md->mask / 2 || diff < 0) {
 			fprintf(stderr, "WARNING: failed to keep up with mmap data.\n");
 			/*
 			 * head points to a known good entry, start there.
 			 */
 			old = head;
 		}
 	}
 	if (old != head) {
 		size_t size;
 		event = (union perf_event *)&data[old & md->mask];
 		size = event->header.size;
 		/*
 		 * Event straddles the mmap boundary -- header should always
 		 * be inside due to u64 alignment of output.
 		 */
 		if ((old & md->mask) + size != ((old + size) & md->mask)) {
 			unsigned int offset = old;
 			unsigned int len = min(sizeof(*event), size), cpy;
 			void *dst = &md->event_copy;
 			do {
 				cpy = min(md->mask + 1 - (offset & md->mask), len);
 				memcpy(dst, &data[offset & md->mask], cpy);
 				offset += cpy;
 				dst += cpy;
 				len -= cpy;
 			} while (len);
 			event = &md->event_copy;
 		}
 		old += size;
 	}
 	md->prev = old;
 	if (!evlist->overwrite)
 		perf_mmap__write_tail(md, old);
 	return event;
 }
 static void __perf_evlist__munmap(struct perf_evlist *evlist, int idx)
 {
 	if (evlist->mmap[idx].base != NULL) {
 		munmap(evlist->mmap[idx].base, evlist->mmap_len);
 		evlist->mmap[idx].base = NULL;
 	}
 }
 void perf_evlist__munmap(struct perf_evlist *evlist)
 {
 	int i;
 	for (i = 0; i < evlist->nr_mmaps; i++)
 		__perf_evlist__munmap(evlist, i);
 	free(evlist->mmap);
 	evlist->mmap = NULL;
 }
 static int perf_evlist__alloc_mmap(struct perf_evlist *evlist)
 {
 	evlist->nr_mmaps = cpu_map__nr(evlist->cpus);
 	if (cpu_map__empty(evlist->cpus))
 		evlist->nr_mmaps = thread_map__nr(evlist->threads);
 	evlist->mmap = zalloc(evlist->nr_mmaps * sizeof(struct perf_mmap));
 	return evlist->mmap != NULL ? 0 : -ENOMEM;
 }
 static int __perf_evlist__mmap(struct perf_evlist *evlist,
 			       int idx, int prot, int mask, int fd)
 {
 	evlist->mmap[idx].prev = 0;
 	evlist->mmap[idx].mask = mask;
 	evlist->mmap[idx].base = mmap(NULL, evlist->mmap_len, prot,
 				      MAP_SHARED, fd, 0);
 	if (evlist->mmap[idx].base == MAP_FAILED) {
 		evlist->mmap[idx].base = NULL;
 		return -1;
 	}
 	perf_evlist__add_pollfd(evlist, fd);
 	return 0;
 }
 static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist, int prot, int mask)
 {
 	struct perf_evsel *evsel;
 	int cpu, thread;
 	int nr_cpus = cpu_map__nr(evlist->cpus);
 	int nr_threads = thread_map__nr(evlist->threads);
 	pr_debug2("perf event ring buffer mmapped per cpu\n");
 	for (cpu = 0; cpu < nr_cpus; cpu++) {
 		int output = -1;
 		for (thread = 0; thread < nr_threads; thread++) {
 			list_for_each_entry(evsel, &evlist->entries, node) {
 				int fd = FD(evsel, cpu, thread);
 				if (output == -1) {
 					output = fd;
 					if (__perf_evlist__mmap(evlist, cpu,
 								prot, mask, output) < 0)
 						goto out_unmap;
 				} else {
 					if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, output) != 0)
 						goto out_unmap;
 				}
 				if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
 				    perf_evlist__id_add_fd(evlist, evsel, cpu, thread, fd) < 0)
 					goto out_unmap;
 			}
 		}
 	}
 	return 0;
 out_unmap:
 	for (cpu = 0; cpu < nr_cpus; cpu++)
 		__perf_evlist__munmap(evlist, cpu);
 	return -1;
 }
 static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist, int prot, int mask)
 {
 	struct perf_evsel *evsel;
 	int thread;
 	int nr_threads = thread_map__nr(evlist->threads);
 	pr_debug2("perf event ring buffer mmapped per thread\n");
 	for (thread = 0; thread < nr_threads; thread++) {
 		int output = -1;
 		list_for_each_entry(evsel, &evlist->entries, node) {
 			int fd = FD(evsel, 0, thread);
 			if (output == -1) {
 				output = fd;
 				if (__perf_evlist__mmap(evlist, thread,
 							prot, mask, output) < 0)
 					goto out_unmap;
 			} else {
 				if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, output) != 0)
 					goto out_unmap;
 			}
 			if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
 			    perf_evlist__id_add_fd(evlist, evsel, 0, thread, fd) < 0)
 				goto out_unmap;
 		}
 	}
 	return 0;
 out_unmap:
 	for (thread = 0; thread < nr_threads; thread++)
 		__perf_evlist__munmap(evlist, thread);
 	return -1;
 }
 /** perf_evlist__mmap - Create per cpu maps to receive events
  *
  * @evlist - list of events
  * @pages - map length in pages
  * @overwrite - overwrite older events?
  *
  * If overwrite is false the user needs to signal event consuption using:
  *
  *	struct perf_mmap *m = &evlist->mmap[cpu];
  *	unsigned int head = perf_mmap__read_head(m);
  *
  *	perf_mmap__write_tail(m, head)
  *
  * Using perf_evlist__read_on_cpu does this automatically.
  */
 int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
 		      bool overwrite)
 {
 	struct perf_evsel *evsel;
 	const struct cpu_map *cpus = evlist->cpus;
 	const struct thread_map *threads = evlist->threads;
 	int prot = PROT_READ | (overwrite ? 0 : PROT_WRITE), mask;
         /* 512 kiB: default amount of unprivileged mlocked memory */
         if (pages == UINT_MAX)
                 pages = (512 * 1024) / page_size;
 	else if (!is_power_of_2(pages))
 		return -EINVAL;
 	mask = pages * page_size - 1;
 	if (evlist->mmap == NULL && perf_evlist__alloc_mmap(evlist) < 0)
 		return -ENOMEM;
 	if (evlist->pollfd == NULL && perf_evlist__alloc_pollfd(evlist) < 0)
 		return -ENOMEM;
 	evlist->overwrite = overwrite;
 	evlist->mmap_len = (pages + 1) * page_size;
 	list_for_each_entry(evsel, &evlist->entries, node) {
 		if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
 		    evsel->sample_id == NULL &&
 		    perf_evsel__alloc_id(evsel, cpu_map__nr(cpus), threads->nr) < 0)
 			return -ENOMEM;
 	}
 	if (cpu_map__empty(cpus))
 		return perf_evlist__mmap_per_thread(evlist, prot, mask);
 	return perf_evlist__mmap_per_cpu(evlist, prot, mask);
 }
 int perf_evlist__create_maps(struct perf_evlist *evlist,
 			     struct perf_target *target)
 {
 	evlist->threads = thread_map__new_str(target->pid, target->tid,
 					      target->uid);
 	if (evlist->threads == NULL)
 		return -1;
 	if (perf_target__has_task(target))
 		evlist->cpus = cpu_map__dummy_new();
 	else if (!perf_target__has_cpu(target) && !target->uses_mmap)
 		evlist->cpus = cpu_map__dummy_new();
 	else
 		evlist->cpus = cpu_map__new(target->cpu_list);
 	if (evlist->cpus == NULL)
 		goto out_delete_threads;
 	return 0;
 out_delete_threads:
 	thread_map__delete(evlist->threads);
 	return -1;
 }
 void perf_evlist__delete_maps(struct perf_evlist *evlist)
 {
 	cpu_map__delete(evlist->cpus);
 	thread_map__delete(evlist->threads);
 	evlist->cpus	= NULL;
 	evlist->threads = NULL;
 }
 int perf_evlist__apply_filters(struct perf_evlist *evlist)
 {
 	struct perf_evsel *evsel;
 	int err = 0;
 	const int ncpus = cpu_map__nr(evlist->cpus),
 		  nthreads = thread_map__nr(evlist->threads);
 	list_for_each_entry(evsel, &evlist->entries, node) {
 		if (evsel->filter == NULL)
 			continue;
 		err = perf_evsel__set_filter(evsel, ncpus, nthreads, evsel->filter);
 		if (err)
 			break;
 	}
 	return err;
 }
 int perf_evlist__set_filter(struct perf_evlist *evlist, const char *filter)
 {
 	struct perf_evsel *evsel;
 	int err = 0;
 	const int ncpus = cpu_map__nr(evlist->cpus),
 		  nthreads = thread_map__nr(evlist->threads);
 	list_for_each_entry(evsel, &evlist->entries, node) {
 		err = perf_evsel__set_filter(evsel, ncpus, nthreads, filter);
 		if (err)
 			break;
 	}
 	return err;
 }
 bool perf_evlist__valid_sample_type(struct perf_evlist *evlist)
 {
 	struct perf_evsel *pos;
 	if (evlist->nr_entries == 1)
 		return true;
 	if (evlist->id_pos < 0 || evlist->is_pos < 0)
 		return false;
 	list_for_each_entry(pos, &evlist->entries, node) {
 		if (pos->id_pos != evlist->id_pos ||
 		    pos->is_pos != evlist->is_pos)
 			return false;
 	}
 	return true;
 }
 u64 __perf_evlist__combined_sample_type(struct perf_evlist *evlist)
 {
 	struct perf_evsel *evsel;
 	if (evlist->combined_sample_type)
 		return evlist->combined_sample_type;
 	list_for_each_entry(evsel, &evlist->entries, node)
 		evlist->combined_sample_type |= evsel->attr.sample_type;
 	return evlist->combined_sample_type;
 }
 u64 perf_evlist__combined_sample_type(struct perf_evlist *evlist)
 {
 	evlist->combined_sample_type = 0;
 	return __perf_evlist__combined_sample_type(evlist);
 }
 bool perf_evlist__valid_read_format(struct perf_evlist *evlist)
 {
 	struct perf_evsel *first = perf_evlist__first(evlist), *pos = first;
 	u64 read_format = first->attr.read_format;
 	u64 sample_type = first->attr.sample_type;
 	list_for_each_entry_continue(pos, &evlist->entries, node) {
 		if (read_format != pos->attr.read_format)
 			return false;
 	}
 	/* PERF_SAMPLE_READ imples PERF_FORMAT_ID. */
 	if ((sample_type & PERF_SAMPLE_READ) &&
 	    !(read_format & PERF_FORMAT_ID)) {
 		return false;
 	}
 	return true;
 }
 u64 perf_evlist__read_format(struct perf_evlist *evlist)
 {
 	struct perf_evsel *first = perf_evlist__first(evlist);
 	return first->attr.read_format;
 }
 u16 perf_evlist__id_hdr_size(struct perf_evlist *evlist)
 {
 	struct perf_evsel *first = perf_evlist__first(evlist);
 	struct perf_sample *data;
 	u64 sample_type;
 	u16 size = 0;
 	if (!first->attr.sample_id_all)
 		goto out;
 	sample_type = first->attr.sample_type;
 	if (sample_type & PERF_SAMPLE_TID)
 		size += sizeof(data->tid) * 2;
        if (sample_type & PERF_SAMPLE_TIME)
 		size += sizeof(data->time);
 	if (sample_type & PERF_SAMPLE_ID)
 		size += sizeof(data->id);
 	if (sample_type & PERF_SAMPLE_STREAM_ID)
 		size += sizeof(data->stream_id);
 	if (sample_type & PERF_SAMPLE_CPU)
 		size += sizeof(data->cpu) * 2;
 	if (sample_type & PERF_SAMPLE_IDENTIFIER)
 		size += sizeof(data->id);
 out:
 	return size;
 }
 bool perf_evlist__valid_sample_id_all(struct perf_evlist *evlist)
 {
 	struct perf_evsel *first = perf_evlist__first(evlist), *pos = first;
 	list_for_each_entry_continue(pos, &evlist->entries, node) {
 		if (first->attr.sample_id_all != pos->attr.sample_id_all)
 			return false;
 	}
 	return true;
 }
 bool perf_evlist__sample_id_all(struct perf_evlist *evlist)
 {
 	struct perf_evsel *first = perf_evlist__first(evlist);
 	return first->attr.sample_id_all;
 }
 void perf_evlist__set_selected(struct perf_evlist *evlist,
 			       struct perf_evsel *evsel)
 {
 	evlist->selected = evsel;
 }
 void perf_evlist__close(struct perf_evlist *evlist)
 {
 	struct perf_evsel *evsel;
 	int ncpus = cpu_map__nr(evlist->cpus);
 	int nthreads = thread_map__nr(evlist->threads);
 	list_for_each_entry_reverse(evsel, &evlist->entries, node)
 		perf_evsel__close(evsel, ncpus, nthreads);
 }
 int perf_evlist__open(struct perf_evlist *evlist)
 {
 	struct perf_evsel *evsel;
 	int err;
 	list_for_each_entry(evsel, &evlist->entries, node) {
 		err = perf_evsel__open(evsel, evlist->cpus, evlist->threads);
 		if (err < 0)
 			goto out_err;
 	}
 	return 0;
 out_err:
 	perf_evlist__close(evlist);
 	errno = -err;
 	return err;
 }
 int perf_evlist__prepare_workload(struct perf_evlist *evlist,
 				  struct perf_target *target,
 				  const char *argv[], bool pipe_output,
 				  bool want_signal)
 {
 	int child_ready_pipe[2], go_pipe[2];
 	char bf;
 	if (pipe(child_ready_pipe) < 0) {
 		perror("failed to create 'ready' pipe");
 		return -1;
 	}
 	if (pipe(go_pipe) < 0) {
 		perror("failed to create 'go' pipe");
 		goto out_close_ready_pipe;
 	}
 	evlist->workload.pid = fork();
 	if (evlist->workload.pid < 0) {
 		perror("failed to fork");
 		goto out_close_pipes;
 	}
 	if (!evlist->workload.pid) {
 		if (pipe_output)
 			dup2(2, 1);
 		signal(SIGTERM, SIG_DFL);
 		close(child_ready_pipe[0]);
 		close(go_pipe[1]);
 		fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
 		/*
 		 * Tell the parent we're ready to go
 		 */
 		close(child_ready_pipe[1]);
 		/*
 		 * Wait until the parent tells us to go.
 		 */
 		if (read(go_pipe[0], &bf, 1) == -1)
 			perror("unable to read pipe");
 		execvp(argv[0], (char **)argv);
 		perror(argv[0]);
 		if (want_signal)
 			kill(getppid(), SIGUSR1);
 		exit(-1);
 	}
 	if (perf_target__none(target))
 		evlist->threads->map[0] = evlist->workload.pid;
 	close(child_ready_pipe[1]);
 	close(go_pipe[0]);
 	/*
 	 * wait for child to settle
 	 */
 	if (read(child_ready_pipe[0], &bf, 1) == -1) {
 		perror("unable to read pipe");
 		goto out_close_pipes;
 	}
 	fcntl(go_pipe[1], F_SETFD, FD_CLOEXEC);
 	evlist->workload.cork_fd = go_pipe[1];
 	close(child_ready_pipe[0]);
 	return 0;
 out_close_pipes:
 	close(go_pipe[0]);
 	close(go_pipe[1]);
 out_close_ready_pipe:
 	close(child_ready_pipe[0]);
 	close(child_ready_pipe[1]);
 	return -1;
 }
 int perf_evlist__start_workload(struct perf_evlist *evlist)
 {
 	if (evlist->workload.cork_fd > 0) {
 		char bf = 0;
 		int ret;
 		/*
 		 * Remove the cork, let it rip!
 		 */
 		ret = write(evlist->workload.cork_fd, &bf, 1);
 		if (ret < 0)
 			perror("enable to write to pipe");
 		close(evlist->workload.cork_fd);
 		return ret;
 	}
 	return 0;
 }
 int perf_evlist__parse_sample(struct perf_evlist *evlist, union perf_event *event,
 			      struct perf_sample *sample)
 {
 	struct perf_evsel *evsel = perf_evlist__event2evsel(evlist, event);
 	if (!evsel)
 		return -EFAULT;
 	return perf_evsel__parse_sample(evsel, event, sample);
 }
 size_t perf_evlist__fprintf(struct perf_evlist *evlist, FILE *fp)
 {
 	struct perf_evsel *evsel;
 	size_t printed = 0;
 	list_for_each_entry(evsel, &evlist->entries, node) {
 		printed += fprintf(fp, "%s%s", evsel->idx ? ", " : "",
 				   perf_evsel__name(evsel));
 	}
 	return printed + fprintf(fp, "\n");;
 }

tools/perf/util/session.c

Diff comments View file @ 72f4a11

 #include <linux/kernel.h>
 #include <traceevent/event-parse.h>
 #include <byteswap.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/mman.h>
 #include "evlist.h"
 #include "evsel.h"
 #include "session.h"
 #include "tool.h"
 #include "sort.h"
 #include "util.h"
 #include "cpumap.h"
 #include "perf_regs.h"
 #include "vdso.h"
 static int perf_session__open(struct perf_session *self, bool force)
 {
 	struct stat input_stat;
 	if (!strcmp(self->filename, "-")) {
 		self->fd_pipe = true;
 		self->fd = STDIN_FILENO;
 		if (perf_session__read_header(self) < 0)
 			pr_err("incompatible file format (rerun with -v to learn more)");
 		return 0;
 	}
 	self->fd = open(self->filename, O_RDONLY);
 	if (self->fd < 0) {
 		int err = errno;
 		pr_err("failed to open %s: %s", self->filename, strerror(err));
 		if (err == ENOENT && !strcmp(self->filename, "perf.data"))
 			pr_err("  (try 'perf record' first)");
 		pr_err("\n");
 		return -errno;
 	}
 	if (fstat(self->fd, &input_stat) < 0)
 		goto out_close;
 	if (!force && input_stat.st_uid && (input_stat.st_uid != geteuid())) {
 		pr_err("file %s not owned by current user or root\n",
 		       self->filename);
 		goto out_close;
 	}
 	if (!input_stat.st_size) {
 		pr_info("zero-sized file (%s), nothing to do!\n",
 			self->filename);
 		goto out_close;
 	}
 	if (perf_session__read_header(self) < 0) {
 		pr_err("incompatible file format (rerun with -v to learn more)");
 		goto out_close;
 	}
 	if (!perf_evlist__valid_sample_type(self->evlist)) {
 		pr_err("non matching sample_type");
 		goto out_close;
 	}
 	if (!perf_evlist__valid_sample_id_all(self->evlist)) {
 		pr_err("non matching sample_id_all");
 		goto out_close;
 	}
 	if (!perf_evlist__valid_read_format(self->evlist)) {
 		pr_err("non matching read_format");
 		goto out_close;
 	}
 	self->size = input_stat.st_size;
 	return 0;
 out_close:
 	close(self->fd);
 	self->fd = -1;
 	return -1;
 }
 void perf_session__set_id_hdr_size(struct perf_session *session)
 {
 	u16 id_hdr_size = perf_evlist__id_hdr_size(session->evlist);
 	machines__set_id_hdr_size(&session->machines, id_hdr_size);
 }
 int perf_session__create_kernel_maps(struct perf_session *self)
 {
 	int ret = machine__create_kernel_maps(&self->machines.host);
 	if (ret >= 0)
 		ret = machines__create_guest_kernel_maps(&self->machines);
 	return ret;
 }
 static void perf_session__destroy_kernel_maps(struct perf_session *self)
 {
 	machines__destroy_kernel_maps(&self->machines);
 }
 struct perf_session *perf_session__new(const char *filename, int mode,
 				       bool force, bool repipe,
 				       struct perf_tool *tool)
 {
 	struct perf_session *self;
 	struct stat st;
 	size_t len;
 	if (!filename || !strlen(filename)) {
 		if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode))
 			filename = "-";
 		else
 			filename = "perf.data";
 	}
 	len = strlen(filename);
 	self = zalloc(sizeof(*self) + len);
 	if (self == NULL)
 		goto out;
 	memcpy(self->filename, filename, len);
 	self->repipe = repipe;
 	INIT_LIST_HEAD(&self->ordered_samples.samples);
 	INIT_LIST_HEAD(&self->ordered_samples.sample_cache);
 	INIT_LIST_HEAD(&self->ordered_samples.to_free);
 	machines__init(&self->machines);
 	if (mode == O_RDONLY) {
 		if (perf_session__open(self, force) < 0)
 			goto out_delete;
 		perf_session__set_id_hdr_size(self);
 	} else if (mode == O_WRONLY) {
 		/*
 		 * In O_RDONLY mode this will be performed when reading the
 		 * kernel MMAP event, in perf_event__process_mmap().
 		 */
 		if (perf_session__create_kernel_maps(self) < 0)
 			goto out_delete;
 	}
 	if (tool && tool->ordering_requires_timestamps &&
 	    tool->ordered_samples && !perf_evlist__sample_id_all(self->evlist)) {
 		dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
 		tool->ordered_samples = false;
 	}
 out:
 	return self;
 out_delete:
 	perf_session__delete(self);
 	return NULL;
 }
 static void perf_session__delete_dead_threads(struct perf_session *session)
 {
 	machine__delete_dead_threads(&session->machines.host);
 }
 static void perf_session__delete_threads(struct perf_session *session)
 {
 	machine__delete_threads(&session->machines.host);
 }
 static void perf_session_env__delete(struct perf_session_env *env)
 {
 	free(env->hostname);
 	free(env->os_release);
 	free(env->version);
 	free(env->arch);
 	free(env->cpu_desc);
 	free(env->cpuid);
 	free(env->cmdline);
 	free(env->sibling_cores);
 	free(env->sibling_threads);
 	free(env->numa_nodes);
 	free(env->pmu_mappings);
 }
 void perf_session__delete(struct perf_session *self)
 {
 	perf_session__destroy_kernel_maps(self);
 	perf_session__delete_dead_threads(self);
 	perf_session__delete_threads(self);
 	perf_session_env__delete(&self->header.env);
 	machines__exit(&self->machines);
 	close(self->fd);
 	free(self);
 	vdso__exit();
 }
 static int process_event_synth_tracing_data_stub(struct perf_tool *tool
 						 __maybe_unused,
 						 union perf_event *event
 						 __maybe_unused,
 						 struct perf_session *session
 						__maybe_unused)
 {
 	dump_printf(": unhandled!\n");
 	return 0;
 }
 static int process_event_synth_attr_stub(struct perf_tool *tool __maybe_unused,
 					 union perf_event *event __maybe_unused,
 					 struct perf_evlist **pevlist
 					 __maybe_unused)
 {
 	dump_printf(": unhandled!\n");
 	return 0;
 }
 static int process_event_sample_stub(struct perf_tool *tool __maybe_unused,
 				     union perf_event *event __maybe_unused,
 				     struct perf_sample *sample __maybe_unused,
 				     struct perf_evsel *evsel __maybe_unused,
 				     struct machine *machine __maybe_unused)
 {
 	dump_printf(": unhandled!\n");
 	return 0;
 }
 static int process_event_stub(struct perf_tool *tool __maybe_unused,
 			      union perf_event *event __maybe_unused,
 			      struct perf_sample *sample __maybe_unused,
 			      struct machine *machine __maybe_unused)
 {
 	dump_printf(": unhandled!\n");
 	return 0;
 }
 static int process_finished_round_stub(struct perf_tool *tool __maybe_unused,
 				       union perf_event *event __maybe_unused,
 				       struct perf_session *perf_session
 				       __maybe_unused)
 {
 	dump_printf(": unhandled!\n");
 	return 0;
 }
 static int process_finished_round(struct perf_tool *tool,
 				  union perf_event *event,
 				  struct perf_session *session);
 void perf_tool__fill_defaults(struct perf_tool *tool)
 {
 	if (tool->sample == NULL)
 		tool->sample = process_event_sample_stub;
 	if (tool->mmap == NULL)
 		tool->mmap = process_event_stub;
 	if (tool->comm == NULL)
 		tool->comm = process_event_stub;
 	if (tool->fork == NULL)
 		tool->fork = process_event_stub;
 	if (tool->exit == NULL)
 		tool->exit = process_event_stub;
 	if (tool->lost == NULL)
 		tool->lost = perf_event__process_lost;
 	if (tool->read == NULL)
 		tool->read = process_event_sample_stub;
 	if (tool->throttle == NULL)
 		tool->throttle = process_event_stub;
 	if (tool->unthrottle == NULL)
 		tool->unthrottle = process_event_stub;
 	if (tool->attr == NULL)
 		tool->attr = process_event_synth_attr_stub;
 	if (tool->tracing_data == NULL)
 		tool->tracing_data = process_event_synth_tracing_data_stub;
 	if (tool->build_id == NULL)
 		tool->build_id = process_finished_round_stub;
 	if (tool->finished_round == NULL) {
 		if (tool->ordered_samples)
 			tool->finished_round = process_finished_round;
 		else
 			tool->finished_round = process_finished_round_stub;
 	}
 }
 void mem_bswap_32(void *src, int byte_size)
 {
 	u32 *m = src;
 	while (byte_size > 0) {
 		*m = bswap_32(*m);
 		byte_size -= sizeof(u32);
 		++m;
 	}
 }
 void mem_bswap_64(void *src, int byte_size)
 {
 	u64 *m = src;
 	while (byte_size > 0) {
 		*m = bswap_64(*m);
 		byte_size -= sizeof(u64);
 		++m;
 	}
 }
 static void swap_sample_id_all(union perf_event *event, void *data)
 {
 	void *end = (void *) event + event->header.size;
 	int size = end - data;
 	BUG_ON(size % sizeof(u64));
 	mem_bswap_64(data, size);
 }
 static void perf_event__all64_swap(union perf_event *event,
 				   bool sample_id_all __maybe_unused)
 {
 	struct perf_event_header *hdr = &event->header;
 	mem_bswap_64(hdr + 1, event->header.size - sizeof(*hdr));
 }
 static void perf_event__comm_swap(union perf_event *event, bool sample_id_all)
 {
 	event->comm.pid = bswap_32(event->comm.pid);
 	event->comm.tid = bswap_32(event->comm.tid);
 	if (sample_id_all) {
 		void *data = &event->comm.comm;
 		data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
 		swap_sample_id_all(event, data);
 	}
 }
 static void perf_event__mmap_swap(union perf_event *event,
 				  bool sample_id_all)
 {
 	event->mmap.pid	  = bswap_32(event->mmap.pid);
 	event->mmap.tid	  = bswap_32(event->mmap.tid);
 	event->mmap.start = bswap_64(event->mmap.start);
 	event->mmap.len	  = bswap_64(event->mmap.len);
 	event->mmap.pgoff = bswap_64(event->mmap.pgoff);
 	if (sample_id_all) {
 		void *data = &event->mmap.filename;
 		data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
 		swap_sample_id_all(event, data);
 	}
 }
 static void perf_event__task_swap(union perf_event *event, bool sample_id_all)
 {
 	event->fork.pid	 = bswap_32(event->fork.pid);
 	event->fork.tid	 = bswap_32(event->fork.tid);
 	event->fork.ppid = bswap_32(event->fork.ppid);
 	event->fork.ptid = bswap_32(event->fork.ptid);
 	event->fork.time = bswap_64(event->fork.time);
 	if (sample_id_all)
 		swap_sample_id_all(event, &event->fork + 1);
 }
 static void perf_event__read_swap(union perf_event *event, bool sample_id_all)
 {
 	event->read.pid		 = bswap_32(event->read.pid);
 	event->read.tid		 = bswap_32(event->read.tid);
 	event->read.value	 = bswap_64(event->read.value);
 	event->read.time_enabled = bswap_64(event->read.time_enabled);
 	event->read.time_running = bswap_64(event->read.time_running);
 	event->read.id		 = bswap_64(event->read.id);
 	if (sample_id_all)
 		swap_sample_id_all(event, &event->read + 1);
 }
 static u8 revbyte(u8 b)
 {
 	int rev = (b >> 4) | ((b & 0xf) << 4);
 	rev = ((rev & 0xcc) >> 2) | ((rev & 0x33) << 2);
 	rev = ((rev & 0xaa) >> 1) | ((rev & 0x55) << 1);
 	return (u8) rev;
 }
 /*
  * XXX this is hack in attempt to carry flags bitfield
  * throught endian village. ABI says:
  *
  * Bit-fields are allocated from right to left (least to most significant)
  * on little-endian implementations and from left to right (most to least
  * significant) on big-endian implementations.
  *
  * The above seems to be byte specific, so we need to reverse each
  * byte of the bitfield. 'Internet' also says this might be implementation
  * specific and we probably need proper fix and carry perf_event_attr
  * bitfield flags in separate data file FEAT_ section. Thought this seems
  * to work for now.
  */
 static void swap_bitfield(u8 *p, unsigned len)
 {
 	unsigned i;
 	for (i = 0; i < len; i++) {
 		*p = revbyte(*p);
 		p++;
 	}
 }
 /* exported for swapping attributes in file header */
 void perf_event__attr_swap(struct perf_event_attr *attr)
 {
 	attr->type		= bswap_32(attr->type);
 	attr->size		= bswap_32(attr->size);
 	attr->config		= bswap_64(attr->config);
 	attr->sample_period	= bswap_64(attr->sample_period);
 	attr->sample_type	= bswap_64(attr->sample_type);
 	attr->read_format	= bswap_64(attr->read_format);
 	attr->wakeup_events	= bswap_32(attr->wakeup_events);
 	attr->bp_type		= bswap_32(attr->bp_type);
 	attr->bp_addr		= bswap_64(attr->bp_addr);
 	attr->bp_len		= bswap_64(attr->bp_len);
 	swap_bitfield((u8 *) (&attr->read_format + 1), sizeof(u64));
 }
 static void perf_event__hdr_attr_swap(union perf_event *event,
 				      bool sample_id_all __maybe_unused)
 {
 	size_t size;
 	perf_event__attr_swap(&event->attr.attr);
 	size = event->header.size;
 	size -= (void *)&event->attr.id - (void *)event;
 	mem_bswap_64(event->attr.id, size);
 }
 static void perf_event__event_type_swap(union perf_event *event,
 					bool sample_id_all __maybe_unused)
 {
 	event->event_type.event_type.event_id =
 		bswap_64(event->event_type.event_type.event_id);
 }
 static void perf_event__tracing_data_swap(union perf_event *event,
 					  bool sample_id_all __maybe_unused)
 {
 	event->tracing_data.size = bswap_32(event->tracing_data.size);
 }
 typedef void (*perf_event__swap_op)(union perf_event *event,
 				    bool sample_id_all);
 static perf_event__swap_op perf_event__swap_ops[] = {
 	[PERF_RECORD_MMAP]		  = perf_event__mmap_swap,
 	[PERF_RECORD_COMM]		  = perf_event__comm_swap,
 	[PERF_RECORD_FORK]		  = perf_event__task_swap,
 	[PERF_RECORD_EXIT]		  = perf_event__task_swap,
 	[PERF_RECORD_LOST]		  = perf_event__all64_swap,
 	[PERF_RECORD_READ]		  = perf_event__read_swap,
 	[PERF_RECORD_SAMPLE]		  = perf_event__all64_swap,
 	[PERF_RECORD_HEADER_ATTR]	  = perf_event__hdr_attr_swap,
 	[PERF_RECORD_HEADER_EVENT_TYPE]	  = perf_event__event_type_swap,
 	[PERF_RECORD_HEADER_TRACING_DATA] = perf_event__tracing_data_swap,
 	[PERF_RECORD_HEADER_BUILD_ID]	  = NULL,
 	[PERF_RECORD_HEADER_MAX]	  = NULL,
 };
 struct sample_queue {
 	u64			timestamp;
 	u64			file_offset;
 	union perf_event	*event;
 	struct list_head	list;
 };
 static void perf_session_free_sample_buffers(struct perf_session *session)
 {
 	struct ordered_samples *os = &session->ordered_samples;
 	while (!list_empty(&os->to_free)) {
 		struct sample_queue *sq;
 		sq = list_entry(os->to_free.next, struct sample_queue, list);
 		list_del(&sq->list);
 		free(sq);
 	}
 }
 static int perf_session_deliver_event(struct perf_session *session,
 				      union perf_event *event,
 				      struct perf_sample *sample,
 				      struct perf_tool *tool,
 				      u64 file_offset);
 static int flush_sample_queue(struct perf_session *s,
 		       struct perf_tool *tool)
 {
 	struct ordered_samples *os = &s->ordered_samples;
 	struct list_head *head = &os->samples;
 	struct sample_queue *tmp, *iter;
 	struct perf_sample sample;
 	u64 limit = os->next_flush;
 	u64 last_ts = os->last_sample ? os->last_sample->timestamp : 0ULL;
 	unsigned idx = 0, progress_next = os->nr_samples / 16;
+	bool show_progress = limit == ULLONG_MAX;
 	int ret;
 	if (!tool->ordered_samples || !limit)
 		return 0;
 	list_for_each_entry_safe(iter, tmp, head, list) {
 		if (iter->timestamp > limit)
 			break;
 		ret = perf_evlist__parse_sample(s->evlist, iter->event, &sample);
 		if (ret)
 			pr_err("Can't parse sample, err = %d\n", ret);
 		else {
 			ret = perf_session_deliver_event(s, iter->event, &sample, tool,
 							 iter->file_offset);
 			if (ret)
 				return ret;
 		}
 		os->last_flush = iter->timestamp;
 		list_del(&iter->list);
 		list_add(&iter->list, &os->sample_cache);
-		if (++idx >= progress_next) {
+		if (show_progress && (++idx >= progress_next)) {
 			progress_next += os->nr_samples / 16;
 			ui_progress__update(idx, os->nr_samples,
 					    "Processing time ordered events...");
 		}
 	}
 	if (list_empty(head)) {
 		os->last_sample = NULL;
 	} else if (last_ts <= limit) {
 		os->last_sample =
 			list_entry(head->prev, struct sample_queue, list);
 	}
 	os->nr_samples = 0;
 	return 0;
 }
 /*
  * When perf record finishes a pass on every buffers, it records this pseudo
  * event.
  * We record the max timestamp t found in the pass n.
  * Assuming these timestamps are monotonic across cpus, we know that if
  * a buffer still has events with timestamps below t, they will be all
  * available and then read in the pass n + 1.
  * Hence when we start to read the pass n + 2, we can safely flush every
  * events with timestamps below t.
  *
  *    ============ PASS n =================
  *       CPU 0         |   CPU 1
  *                     |
  *    cnt1 timestamps  |   cnt2 timestamps
  *          1          |         2
  *          2          |         3
  *          -          |         4  <--- max recorded
  *
  *    ============ PASS n + 1 ==============
  *       CPU 0         |   CPU 1
  *                     |
  *    cnt1 timestamps  |   cnt2 timestamps
  *          3          |         5
  *          4          |         6
  *          5          |         7 <---- max recorded
  *
  *      Flush every events below timestamp 4
  *
  *    ============ PASS n + 2 ==============
  *       CPU 0         |   CPU 1
  *                     |
  *    cnt1 timestamps  |   cnt2 timestamps
  *          6          |         8
  *          7          |         9
  *          -          |         10
  *
  *      Flush every events below timestamp 7
  *      etc...
  */
 static int process_finished_round(struct perf_tool *tool,
 				  union perf_event *event __maybe_unused,
 				  struct perf_session *session)
 {
 	int ret = flush_sample_queue(session, tool);
 	if (!ret)
 		session->ordered_samples.next_flush = session->ordered_samples.max_timestamp;
 	return ret;
 }
 /* The queue is ordered by time */
 static void __queue_event(struct sample_queue *new, struct perf_session *s)
 {
 	struct ordered_samples *os = &s->ordered_samples;
 	struct sample_queue *sample = os->last_sample;
 	u64 timestamp = new->timestamp;
 	struct list_head *p;
 	++os->nr_samples;
 	os->last_sample = new;
 	if (!sample) {
 		list_add(&new->list, &os->samples);
 		os->max_timestamp = timestamp;
 		return;
 	}
 	/*
 	 * last_sample might point to some random place in the list as it's
 	 * the last queued event. We expect that the new event is close to
 	 * this.
 	 */
 	if (sample->timestamp <= timestamp) {
 		while (sample->timestamp <= timestamp) {
 			p = sample->list.next;
 			if (p == &os->samples) {
 				list_add_tail(&new->list, &os->samples);
 				os->max_timestamp = timestamp;
 				return;
 			}
 			sample = list_entry(p, struct sample_queue, list);
 		}
 		list_add_tail(&new->list, &sample->list);
 	} else {
 		while (sample->timestamp > timestamp) {
 			p = sample->list.prev;
 			if (p == &os->samples) {
 				list_add(&new->list, &os->samples);
 				return;
 			}
 			sample = list_entry(p, struct sample_queue, list);
 		}
 		list_add(&new->list, &sample->list);
 	}
 }
 #define MAX_SAMPLE_BUFFER	(64 * 1024 / sizeof(struct sample_queue))
 int perf_session_queue_event(struct perf_session *s, union perf_event *event,
 				    struct perf_sample *sample, u64 file_offset)
 {
 	struct ordered_samples *os = &s->ordered_samples;
 	struct list_head *sc = &os->sample_cache;
 	u64 timestamp = sample->time;
 	struct sample_queue *new;
 	if (!timestamp || timestamp == ~0ULL)
 		return -ETIME;
 	if (timestamp < s->ordered_samples.last_flush) {
 		printf("Warning: Timestamp below last timeslice flush\n");
 		return -EINVAL;
 	}
 	if (!list_empty(sc)) {
 		new = list_entry(sc->next, struct sample_queue, list);
 		list_del(&new->list);
 	} else if (os->sample_buffer) {
 		new = os->sample_buffer + os->sample_buffer_idx;
 		if (++os->sample_buffer_idx == MAX_SAMPLE_BUFFER)
 			os->sample_buffer = NULL;
 	} else {
 		os->sample_buffer = malloc(MAX_SAMPLE_BUFFER * sizeof(*new));
 		if (!os->sample_buffer)
 			return -ENOMEM;
 		list_add(&os->sample_buffer->list, &os->to_free);
 		os->sample_buffer_idx = 2;
 		new = os->sample_buffer + 1;
 	}
 	new->timestamp = timestamp;
 	new->file_offset = file_offset;
 	new->event = event;
 	__queue_event(new, s);
 	return 0;
 }
 static void callchain__printf(struct perf_sample *sample)
 {
 	unsigned int i;
 	printf("... chain: nr:%" PRIu64 "\n", sample->callchain->nr);
 	for (i = 0; i < sample->callchain->nr; i++)
 		printf("..... %2d: %016" PRIx64 "\n",
 		       i, sample->callchain->ips[i]);
 }
 static void branch_stack__printf(struct perf_sample *sample)
 {
 	uint64_t i;
 	printf("... branch stack: nr:%" PRIu64 "\n", sample->branch_stack->nr);
 	for (i = 0; i < sample->branch_stack->nr; i++)
 		printf("..... %2"PRIu64": %016" PRIx64 " -> %016" PRIx64 "\n",
 			i, sample->branch_stack->entries[i].from,
 			sample->branch_stack->entries[i].to);
 }
 static void regs_dump__printf(u64 mask, u64 *regs)
 {
 	unsigned rid, i = 0;
 	for_each_set_bit(rid, (unsigned long *) &mask, sizeof(mask) * 8) {
 		u64 val = regs[i++];
 		printf(".... %-5s 0x%" PRIx64 "\n",
 		       perf_reg_name(rid), val);
 	}
 }
 static void regs_user__printf(struct perf_sample *sample, u64 mask)
 {
 	struct regs_dump *user_regs = &sample->user_regs;
 	if (user_regs->regs) {
 		printf("... user regs: mask 0x%" PRIx64 "\n", mask);
 		regs_dump__printf(mask, user_regs->regs);
 	}
 }
 static void stack_user__printf(struct stack_dump *dump)
 {
 	printf("... ustack: size %" PRIu64 ", offset 0x%x\n",
 	       dump->size, dump->offset);
 }
 static void perf_session__print_tstamp(struct perf_session *session,
 				       union perf_event *event,
 				       struct perf_sample *sample)
 {
 	u64 sample_type = __perf_evlist__combined_sample_type(session->evlist);
 	if (event->header.type != PERF_RECORD_SAMPLE &&
 	    !perf_evlist__sample_id_all(session->evlist)) {
 		fputs("-1 -1 ", stdout);
 		return;
 	}
 	if ((sample_type & PERF_SAMPLE_CPU))
 		printf("%u ", sample->cpu);
 	if (sample_type & PERF_SAMPLE_TIME)
 		printf("%" PRIu64 " ", sample->time);
 }
 static void sample_read__printf(struct perf_sample *sample, u64 read_format)
 {
 	printf("... sample_read:\n");
 	if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
 		printf("...... time enabled %016" PRIx64 "\n",
 		       sample->read.time_enabled);
 	if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
 		printf("...... time running %016" PRIx64 "\n",
 		       sample->read.time_running);
 	if (read_format & PERF_FORMAT_GROUP) {
 		u64 i;
 		printf(".... group nr %" PRIu64 "\n", sample->read.group.nr);
 		for (i = 0; i < sample->read.group.nr; i++) {
 			struct sample_read_value *value;
 			value = &sample->read.group.values[i];
 			printf("..... id %016" PRIx64
 			       ", value %016" PRIx64 "\n",
 			       value->id, value->value);
 		}
 	} else
 		printf("..... id %016" PRIx64 ", value %016" PRIx64 "\n",
 			sample->read.one.id, sample->read.one.value);
 }
 static void dump_event(struct perf_session *session, union perf_event *event,
 		       u64 file_offset, struct perf_sample *sample)
 {
 	if (!dump_trace)
 		return;
 	printf("\n%#" PRIx64 " [%#x]: event: %d\n",
 	       file_offset, event->header.size, event->header.type);
 	trace_event(event);
 	if (sample)
 		perf_session__print_tstamp(session, event, sample);
 	printf("%#" PRIx64 " [%#x]: PERF_RECORD_%s", file_offset,
 	       event->header.size, perf_event__name(event->header.type));
 }
 static void dump_sample(struct perf_evsel *evsel, union perf_event *event,
 			struct perf_sample *sample)
 {
 	u64 sample_type;
 	if (!dump_trace)
 		return;
 	printf("(IP, %d): %d/%d: %#" PRIx64 " period: %" PRIu64 " addr: %#" PRIx64 "\n",
 	       event->header.misc, sample->pid, sample->tid, sample->ip,
 	       sample->period, sample->addr);
 	sample_type = evsel->attr.sample_type;
 	if (sample_type & PERF_SAMPLE_CALLCHAIN)
 		callchain__printf(sample);
 	if (sample_type & PERF_SAMPLE_BRANCH_STACK)
 		branch_stack__printf(sample);
 	if (sample_type & PERF_SAMPLE_REGS_USER)
 		regs_user__printf(sample, evsel->attr.sample_regs_user);
 	if (sample_type & PERF_SAMPLE_STACK_USER)
 		stack_user__printf(&sample->user_stack);
 	if (sample_type & PERF_SAMPLE_WEIGHT)
 		printf("... weight: %" PRIu64 "\n", sample->weight);
 	if (sample_type & PERF_SAMPLE_DATA_SRC)
 		printf(" . data_src: 0x%"PRIx64"\n", sample->data_src);
 	if (sample_type & PERF_SAMPLE_READ)
 		sample_read__printf(sample, evsel->attr.read_format);
 }
 static struct machine *
 	perf_session__find_machine_for_cpumode(struct perf_session *session,
 					       union perf_event *event,
 					       struct perf_sample *sample)
 {
 	const u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 	if (perf_guest &&
 	    ((cpumode == PERF_RECORD_MISC_GUEST_KERNEL) ||
 	     (cpumode == PERF_RECORD_MISC_GUEST_USER))) {
 		u32 pid;
 		if (event->header.type == PERF_RECORD_MMAP)
 			pid = event->mmap.pid;
 		else
 			pid = sample->pid;
 		return perf_session__findnew_machine(session, pid);
 	}
 	return &session->machines.host;
 }
 static int deliver_sample_value(struct perf_session *session,
 				struct perf_tool *tool,
 				union perf_event *event,
 				struct perf_sample *sample,
 				struct sample_read_value *v,
 				struct machine *machine)
 {
 	struct perf_sample_id *sid;
 	sid = perf_evlist__id2sid(session->evlist, v->id);
 	if (sid) {
 		sample->id     = v->id;
 		sample->period = v->value - sid->period;
 		sid->period    = v->value;
 	}
 	if (!sid || sid->evsel == NULL) {
 		++session->stats.nr_unknown_id;
 		return 0;
 	}
 	return tool->sample(tool, event, sample, sid->evsel, machine);
 }
 static int deliver_sample_group(struct perf_session *session,
 				struct perf_tool *tool,
 				union  perf_event *event,
 				struct perf_sample *sample,
 				struct machine *machine)
 {
 	int ret = -EINVAL;
 	u64 i;
 	for (i = 0; i < sample->read.group.nr; i++) {
 		ret = deliver_sample_value(session, tool, event, sample,
 					   &sample->read.group.values[i],
 					   machine);
 		if (ret)
 			break;
 	}
 	return ret;
 }
 static int
 perf_session__deliver_sample(struct perf_session *session,
 			     struct perf_tool *tool,
 			     union  perf_event *event,
 			     struct perf_sample *sample,
 			     struct perf_evsel *evsel,
 			     struct machine *machine)
 {
 	/* We know evsel != NULL. */
 	u64 sample_type = evsel->attr.sample_type;
 	u64 read_format = evsel->attr.read_format;
 	/* Standard sample delievery. */
 	if (!(sample_type & PERF_SAMPLE_READ))
 		return tool->sample(tool, event, sample, evsel, machine);
 	/* For PERF_SAMPLE_READ we have either single or group mode. */
 	if (read_format & PERF_FORMAT_GROUP)
 		return deliver_sample_group(session, tool, event, sample,
 					    machine);
 	else
 		return deliver_sample_value(session, tool, event, sample,
 					    &sample->read.one, machine);
 }
 static int perf_session_deliver_event(struct perf_session *session,
 				      union perf_event *event,
 				      struct perf_sample *sample,
 				      struct perf_tool *tool,
 				      u64 file_offset)
 {
 	struct perf_evsel *evsel;
 	struct machine *machine;
 	dump_event(session, event, file_offset, sample);
 	evsel = perf_evlist__id2evsel(session->evlist, sample->id);
 	if (evsel != NULL && event->header.type != PERF_RECORD_SAMPLE) {
 		/*
 		 * XXX We're leaving PERF_RECORD_SAMPLE unnacounted here
 		 * because the tools right now may apply filters, discarding
 		 * some of the samples. For consistency, in the future we
 		 * should have something like nr_filtered_samples and remove
 		 * the sample->period from total_sample_period, etc, KISS for
 		 * now tho.
 		 *
 		 * Also testing against NULL allows us to handle files without
 		 * attr.sample_id_all and/or without PERF_SAMPLE_ID. In the
 		 * future probably it'll be a good idea to restrict event
 		 * processing via perf_session to files with both set.
 		 */
 		hists__inc_nr_events(&evsel->hists, event->header.type);
 	}
 	machine = perf_session__find_machine_for_cpumode(session, event,
 							 sample);
 	switch (event->header.type) {
 	case PERF_RECORD_SAMPLE:
 		dump_sample(evsel, event, sample);
 		if (evsel == NULL) {
 			++session->stats.nr_unknown_id;
 			return 0;
 		}
 		if (machine == NULL) {
 			++session->stats.nr_unprocessable_samples;
 			return 0;
 		}
 		return perf_session__deliver_sample(session, tool, event,
 						    sample, evsel, machine);
 	case PERF_RECORD_MMAP:
 		return tool->mmap(tool, event, sample, machine);
 	case PERF_RECORD_COMM:
 		return tool->comm(tool, event, sample, machine);
 	case PERF_RECORD_FORK:
 		return tool->fork(tool, event, sample, machine);
 	case PERF_RECORD_EXIT:
 		return tool->exit(tool, event, sample, machine);
 	case PERF_RECORD_LOST:
 		if (tool->lost == perf_event__process_lost)
 			session->stats.total_lost += event->lost.lost;
 		return tool->lost(tool, event, sample, machine);
 	case PERF_RECORD_READ:
 		return tool->read(tool, event, sample, evsel, machine);
 	case PERF_RECORD_THROTTLE:
 		return tool->throttle(tool, event, sample, machine);
 	case PERF_RECORD_UNTHROTTLE:
 		return tool->unthrottle(tool, event, sample, machine);
 	default:
 		++session->stats.nr_unknown_events;
 		return -1;
 	}
 }
 static int perf_session__process_user_event(struct perf_session *session, union perf_event *event,
 					    struct perf_tool *tool, u64 file_offset)
 {
 	int err;
 	dump_event(session, event, file_offset, NULL);
 	/* These events are processed right away */
 	switch (event->header.type) {
 	case PERF_RECORD_HEADER_ATTR:
 		err = tool->attr(tool, event, &session->evlist);
 		if (err == 0)
 			perf_session__set_id_hdr_size(session);
 		return err;
 	case PERF_RECORD_HEADER_TRACING_DATA:
 		/* setup for reading amidst mmap */
 		lseek(session->fd, file_offset, SEEK_SET);
 		return tool->tracing_data(tool, event, session);
 	case PERF_RECORD_HEADER_BUILD_ID:
 		return tool->build_id(tool, event, session);
 	case PERF_RECORD_FINISHED_ROUND:
 		return tool->finished_round(tool, event, session);
 	default:
 		return -EINVAL;
 	}
 }
 static void event_swap(union perf_event *event, bool sample_id_all)
 {
 	perf_event__swap_op swap;
 	swap = perf_event__swap_ops[event->header.type];
 	if (swap)
 		swap(event, sample_id_all);
 }
 static int perf_session__process_event(struct perf_session *session,
 				       union perf_event *event,
 				       struct perf_tool *tool,
 				       u64 file_offset)
 {
 	struct perf_sample sample;
 	int ret;
 	if (session->header.needs_swap)
 		event_swap(event, perf_evlist__sample_id_all(session->evlist));
 	if (event->header.type >= PERF_RECORD_HEADER_MAX)
 		return -EINVAL;
 	events_stats__inc(&session->stats, event->header.type);
 	if (event->header.type >= PERF_RECORD_USER_TYPE_START)
 		return perf_session__process_user_event(session, event, tool, file_offset);
 	/*
 	 * For all kernel events we get the sample data
 	 */
 	ret = perf_evlist__parse_sample(session->evlist, event, &sample);
 	if (ret)
 		return ret;
 	if (tool->ordered_samples) {
 		ret = perf_session_queue_event(session, event, &sample,
 					       file_offset);
 		if (ret != -ETIME)
 			return ret;
 	}
 	return perf_session_deliver_event(session, event, &sample, tool,
 					  file_offset);
 }
 void perf_event_header__bswap(struct perf_event_header *self)
 {
 	self->type = bswap_32(self->type);
 	self->misc = bswap_16(self->misc);
 	self->size = bswap_16(self->size);
 }
 struct thread *perf_session__findnew(struct perf_session *session, pid_t pid)
 {
 	return machine__findnew_thread(&session->machines.host, 0, pid);
 }
 static struct thread *perf_session__register_idle_thread(struct perf_session *self)
 {
 	struct thread *thread = perf_session__findnew(self, 0);
 	if (thread == NULL || thread__set_comm(thread, "swapper")) {
 		pr_err("problem inserting idle task.\n");
 		thread = NULL;
 	}
 	return thread;
 }
 static void perf_session__warn_about_errors(const struct perf_session *session,
 					    const struct perf_tool *tool)
 {
 	if (tool->lost == perf_event__process_lost &&
 	    session->stats.nr_events[PERF_RECORD_LOST] != 0) {
 		ui__warning("Processed %d events and lost %d chunks!\n\n"
 			    "Check IO/CPU overload!\n\n",
 			    session->stats.nr_events[0],
 			    session->stats.nr_events[PERF_RECORD_LOST]);
 	}
 	if (session->stats.nr_unknown_events != 0) {
 		ui__warning("Found %u unknown events!\n\n"
 			    "Is this an older tool processing a perf.data "
 			    "file generated by a more recent tool?\n\n"
 			    "If that is not the case, consider "
 			    "reporting to linux-kernel@vger.kernel.org.\n\n",
 			    session->stats.nr_unknown_events);
 	}
 	if (session->stats.nr_unknown_id != 0) {
 		ui__warning("%u samples with id not present in the header\n",
 			    session->stats.nr_unknown_id);
 	}
  	if (session->stats.nr_invalid_chains != 0) {
  		ui__warning("Found invalid callchains!\n\n"
  			    "%u out of %u events were discarded for this reason.\n\n"
  			    "Consider reporting to linux-kernel@vger.kernel.org.\n\n",
  			    session->stats.nr_invalid_chains,
  			    session->stats.nr_events[PERF_RECORD_SAMPLE]);
  	}
 	if (session->stats.nr_unprocessable_samples != 0) {
 		ui__warning("%u unprocessable samples recorded.\n"
 			    "Do you have a KVM guest running and not using 'perf kvm'?\n",
 			    session->stats.nr_unprocessable_samples);
 	}
 }
 #define session_done()	(*(volatile int *)(&session_done))
 volatile int session_done;
 static int __perf_session__process_pipe_events(struct perf_session *self,
 					       struct perf_tool *tool)
 {
 	union perf_event *event;
 	uint32_t size, cur_size = 0;
 	void *buf = NULL;
 	int skip = 0;
 	u64 head;
 	int err;
 	void *p;
 	perf_tool__fill_defaults(tool);
 	head = 0;
 	cur_size = sizeof(union perf_event);
 	buf = malloc(cur_size);
 	if (!buf)
 		return -errno;
 more:
 	event = buf;
 	err = readn(self->fd, event, sizeof(struct perf_event_header));
 	if (err <= 0) {
 		if (err == 0)
 			goto done;
 		pr_err("failed to read event header\n");
 		goto out_err;
 	}
 	if (self->header.needs_swap)
 		perf_event_header__bswap(&event->header);
 	size = event->header.size;
 	if (size < sizeof(struct perf_event_header)) {
 		pr_err("bad event header size\n");
 		goto out_err;
 	}
 	if (size > cur_size) {
 		void *new = realloc(buf, size);
 		if (!new) {
 			pr_err("failed to allocate memory to read event\n");
 			goto out_err;
 		}
 		buf = new;
 		cur_size = size;
 		event = buf;
 	}
 	p = event;
 	p += sizeof(struct perf_event_header);
 	if (size - sizeof(struct perf_event_header)) {
 		err = readn(self->fd, p, size - sizeof(struct perf_event_header));
 		if (err <= 0) {
 			if (err == 0) {
 				pr_err("unexpected end of event stream\n");
 				goto done;
 			}
 			pr_err("failed to read event data\n");
 			goto out_err;
 		}
 	}
 	if ((skip = perf_session__process_event(self, event, tool, head)) < 0) {
 		pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
 		       head, event->header.size, event->header.type);
 		err = -EINVAL;
 		goto out_err;
 	}
 	head += size;
 	if (skip > 0)
 		head += skip;
 	if (!session_done())
 		goto more;
 done:
 	err = 0;
 out_err:
 	free(buf);
 	perf_session__warn_about_errors(self, tool);
 	perf_session_free_sample_buffers(self);
 	return err;
 }
 static union perf_event *
 fetch_mmaped_event(struct perf_session *session,
 		   u64 head, size_t mmap_size, char *buf)
 {
 	union perf_event *event;
 	/*
 	 * Ensure we have enough space remaining to read
 	 * the size of the event in the headers.
 	 */
 	if (head + sizeof(event->header) > mmap_size)
 		return NULL;
 	event = (union perf_event *)(buf + head);
 	if (session->header.needs_swap)
 		perf_event_header__bswap(&event->header);
 	if (head + event->header.size > mmap_size) {
 		/* We're not fetching the event so swap back again */
 		if (session->header.needs_swap)
 			perf_event_header__bswap(&event->header);
 		return NULL;
 	}
 	return event;
 }
 /*
  * On 64bit we can mmap the data file in one go. No need for tiny mmap
  * slices. On 32bit we use 32MB.
  */
 #if BITS_PER_LONG == 64
 #define MMAP_SIZE ULLONG_MAX
 #define NUM_MMAPS 1
 #else
 #define MMAP_SIZE (32 * 1024 * 1024ULL)
 #define NUM_MMAPS 128
 #endif
 int __perf_session__process_events(struct perf_session *session,
 				   u64 data_offset, u64 data_size,
 				   u64 file_size, struct perf_tool *tool)
 {
 	u64 head, page_offset, file_offset, file_pos, progress_next;
 	int err, mmap_prot, mmap_flags, map_idx = 0;
 	size_t	mmap_size;
 	char *buf, *mmaps[NUM_MMAPS];
 	union perf_event *event;
 	uint32_t size;
 	perf_tool__fill_defaults(tool);
 	page_offset = page_size * (data_offset / page_size);
 	file_offset = page_offset;
 	head = data_offset - page_offset;
 	if (data_offset + data_size < file_size)
 		file_size = data_offset + data_size;
 	progress_next = file_size / 16;
 	mmap_size = MMAP_SIZE;
 	if (mmap_size > file_size)
 		mmap_size = file_size;
 	memset(mmaps, 0, sizeof(mmaps));
 	mmap_prot  = PROT_READ;
 	mmap_flags = MAP_SHARED;
 	if (session->header.needs_swap) {
 		mmap_prot  |= PROT_WRITE;
 		mmap_flags = MAP_PRIVATE;
 	}
 remap:
 	buf = mmap(NULL, mmap_size, mmap_prot, mmap_flags, session->fd,
 		   file_offset);
 	if (buf == MAP_FAILED) {
 		pr_err("failed to mmap file\n");
 		err = -errno;
 		goto out_err;
 	}
 	mmaps[map_idx] = buf;
 	map_idx = (map_idx + 1) & (ARRAY_SIZE(mmaps) - 1);
 	file_pos = file_offset + head;
 more:
 	event = fetch_mmaped_event(session, head, mmap_size, buf);
 	if (!event) {
 		if (mmaps[map_idx]) {
 			munmap(mmaps[map_idx], mmap_size);
 			mmaps[map_idx] = NULL;
 		}
 		page_offset = page_size * (head / page_size);
 		file_offset += page_offset;
 		head -= page_offset;
 		goto remap;
 	}
 	size = event->header.size;
 	if (size < sizeof(struct perf_event_header) ||
 	    perf_session__process_event(session, event, tool, file_pos) < 0) {
 		pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
 		       file_offset + head, event->header.size,
 		       event->header.type);
 		err = -EINVAL;
 		goto out_err;
 	}
 	head += size;
 	file_pos += size;
 	if (file_pos >= progress_next) {
 		progress_next += file_size / 16;
 		ui_progress__update(file_pos, file_size,
 				    "Processing events...");
 	}
 	if (file_pos < file_size)
 		goto more;
 	err = 0;
 	/* do the final flush for ordered samples */
 	session->ordered_samples.next_flush = ULLONG_MAX;
 	err = flush_sample_queue(session, tool);
 out_err:
 	ui_progress__finish();
 	perf_session__warn_about_errors(session, tool);
 	perf_session_free_sample_buffers(session);
 	return err;
 }
 int perf_session__process_events(struct perf_session *self,
 				 struct perf_tool *tool)
 {
 	int err;
 	if (perf_session__register_idle_thread(self) == NULL)
 		return -ENOMEM;
 	if (!self->fd_pipe)
 		err = __perf_session__process_events(self,
 						     self->header.data_offset,
 						     self->header.data_size,
 						     self->size, tool);
 	else
 		err = __perf_session__process_pipe_events(self, tool);
 	return err;
 }
 bool perf_session__has_traces(struct perf_session *session, const char *msg)
 {
 	struct perf_evsel *evsel;
 	list_for_each_entry(evsel, &session->evlist->entries, node) {
 		if (evsel->attr.type == PERF_TYPE_TRACEPOINT)
 			return true;
 	}
 	pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
 	return false;
 }
 int maps__set_kallsyms_ref_reloc_sym(struct map **maps,
 				     const char *symbol_name, u64 addr)
 {
 	char *bracket;
 	enum map_type i;
 	struct ref_reloc_sym *ref;
 	ref = zalloc(sizeof(struct ref_reloc_sym));
 	if (ref == NULL)
 		return -ENOMEM;
 	ref->name = strdup(symbol_name);
 	if (ref->name == NULL) {
 		free(ref);
 		return -ENOMEM;
 	}
 	bracket = strchr(ref->name, ']');
 	if (bracket)
 		*bracket = '\0';
 	ref->addr = addr;
 	for (i = 0; i < MAP__NR_TYPES; ++i) {
 		struct kmap *kmap = map__kmap(maps[i]);
 		kmap->ref_reloc_sym = ref;
 	}
 	return 0;
 }
 size_t perf_session__fprintf_dsos(struct perf_session *self, FILE *fp)
 {
 	return machines__fprintf_dsos(&self->machines, fp);
 }
 size_t perf_session__fprintf_dsos_buildid(struct perf_session *self, FILE *fp,
 					  bool (skip)(struct dso *dso, int parm), int parm)
 {
 	return machines__fprintf_dsos_buildid(&self->machines, fp, skip, parm);
 }
 size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp)
 {
 	struct perf_evsel *pos;
 	size_t ret = fprintf(fp, "Aggregated stats:\n");
 	ret += events_stats__fprintf(&session->stats, fp);
 	list_for_each_entry(pos, &session->evlist->entries, node) {
 		ret += fprintf(fp, "%s stats:\n", perf_evsel__name(pos));
 		ret += events_stats__fprintf(&pos->hists.stats, fp);
 	}
 	return ret;
 }
 size_t perf_session__fprintf(struct perf_session *session, FILE *fp)
 {
 	/*
 	 * FIXME: Here we have to actually print all the machines in this
 	 * session, not just the host...
 	 */
 	return machine__fprintf(&session->machines.host, fp);
 }
 struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
 					      unsigned int type)
 {
 	struct perf_evsel *pos;
 	list_for_each_entry(pos, &session->evlist->entries, node) {
 		if (pos->attr.type == type)
 			return pos;
 	}
 	return NULL;
 }
 void perf_evsel__print_ip(struct perf_evsel *evsel, union perf_event *event,
 			  struct perf_sample *sample, struct machine *machine,
 			  unsigned int print_opts, unsigned int stack_depth)
 {
 	struct addr_location al;
 	struct callchain_cursor_node *node;
 	int print_ip = print_opts & PRINT_IP_OPT_IP;
 	int print_sym = print_opts & PRINT_IP_OPT_SYM;
 	int print_dso = print_opts & PRINT_IP_OPT_DSO;
 	int print_symoffset = print_opts & PRINT_IP_OPT_SYMOFFSET;
 	int print_oneline = print_opts & PRINT_IP_OPT_ONELINE;
 	char s = print_oneline ? ' ' : '\t';
 	if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) {
 		error("problem processing %d event, skipping it.\n",
 			event->header.type);
 		return;
 	}
 	if (symbol_conf.use_callchain && sample->callchain) {
 		if (machine__resolve_callchain(machine, evsel, al.thread,
 					       sample, NULL, NULL) != 0) {
 			if (verbose)
 				error("Failed to resolve callchain. Skipping\n");
 			return;
 		}
 		callchain_cursor_commit(&callchain_cursor);
 		while (stack_depth) {
 			node = callchain_cursor_current(&callchain_cursor);
 			if (!node)
 				break;
 			if (print_ip)
 				printf("%c%16" PRIx64, s, node->ip);
 			if (print_sym) {
 				printf(" ");
 				if (print_symoffset) {
 					al.addr = node->ip;
 					al.map  = node->map;
 					symbol__fprintf_symname_offs(node->sym, &al, stdout);
 				} else
 					symbol__fprintf_symname(node->sym, stdout);
 			}
 			if (print_dso) {
 				printf(" (");
 				map__fprintf_dsoname(node->map, stdout);
 				printf(")");
 			}
 			if (!print_oneline)
 				printf("\n");
 			callchain_cursor_advance(&callchain_cursor);
 			stack_depth--;
 		}
 	} else {
 		if (print_ip)
 			printf("%16" PRIx64, sample->ip);
 		if (print_sym) {
 			printf(" ");
 			if (print_symoffset)
 				symbol__fprintf_symname_offs(al.sym, &al,
 							     stdout);
 			else
 				symbol__fprintf_symname(al.sym, stdout);
 		}
 		if (print_dso) {
 			printf(" (");
 			map__fprintf_dsoname(al.map, stdout);
 			printf(")");
 		}
 	}
 }
 int perf_session__cpu_bitmap(struct perf_session *session,
 			     const char *cpu_list, unsigned long *cpu_bitmap)
 {
 	int i;
 	struct cpu_map *map;
 	for (i = 0; i < PERF_TYPE_MAX; ++i) {
 		struct perf_evsel *evsel;
 		evsel = perf_session__find_first_evtype(session, i);
 		if (!evsel)
 			continue;
 		if (!(evsel->attr.sample_type & PERF_SAMPLE_CPU)) {
 			pr_err("File does not contain CPU events. "
 			       "Remove -c option to proceed.\n");
 			return -1;
 		}
 	}
 	map = cpu_map__new(cpu_list);
 	if (map == NULL) {
 		pr_err("Invalid cpu_list\n");
 		return -1;
 	}
 	for (i = 0; i < map->nr; i++) {
 		int cpu = map->map[i];
 		if (cpu >= MAX_NR_CPUS) {
 			pr_err("Requested CPU %d too large. "
 			       "Consider raising MAX_NR_CPUS\n", cpu);
 			return -1;
 		}
 		set_bit(cpu, cpu_bitmap);
 	}
 	return 0;
 }
 void perf_session__fprintf_info(struct perf_session *session, FILE *fp,
 				bool full)
 {
 	struct stat st;
 	int ret;
 	if (session == NULL || fp == NULL)
 		return;
 	ret = fstat(session->fd, &st);
 	if (ret == -1)
 		return;
 	fprintf(fp, "# ========\n");
 	fprintf(fp, "# captured on: %s", ctime(&st.st_ctime));
 	perf_header__fprintf_info(session, fp, full);
 	fprintf(fp, "# ========\n#\n");
 }
 int __perf_session__set_tracepoints_handlers(struct perf_session *session,
 					     const struct perf_evsel_str_handler *assocs,
 					     size_t nr_assocs)
 {
 	struct perf_evlist *evlist = session->evlist;
 	struct event_format *format;
 	struct perf_evsel *evsel;
 	char *tracepoint, *name;
 	size_t i;
 	int err;
 	for (i = 0; i < nr_assocs; i++) {
 		err = -ENOMEM;
 		tracepoint = strdup(assocs[i].name);
 		if (tracepoint == NULL)
 			goto out;
 		err = -ENOENT;
 		name = strchr(tracepoint, ':');
 		if (name == NULL)
 			goto out_free;
 		*name++ = '\0';
 		format = pevent_find_event_by_name(session->pevent,
 						   tracepoint, name);
 		if (format == NULL) {
 			/*
 			 * Adding a handler for an event not in the session,
 			 * just ignore it.
 			 */
 			goto next;
 		}
 		evsel = perf_evlist__find_tracepoint_by_id(evlist, format->id);
 		if (evsel == NULL)
 			goto next;
 		err = -EEXIST;
 		if (evsel->handler.func != NULL)
 			goto out_free;
 		evsel->handler.func = assocs[i].handler;
 next:
 		free(tracepoint);
 	}
 	err = 0;
 out:
 	return err;
 out_free:
 	free(tracepoint);
 	goto out;
 }