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

Commit 0a84f007f97ce6fc7c07a481a5b9808b187a0193

Authored by David Daney 2012-01-18 05:41:01 +0800

Committed by Arnaldo Carvalho de Melo 2012-01-31 08:19:54 +0800

Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches

perf tools: Fix broken build by defining _GNU_SOURCE in Makefile

When building on my Debian/mips system, util/util.c fails to build
because commit 1aed2671738785e8f5aea663a6fda91aa7ef59b5 (perf kvm: Do
guest-only counting by default) indirectly includes stdio.h before the
feature selection in util.h is done.  This prevents _GNU_SOURCE in
util.h from enabling the declaration of getline(), from now second
inclusion of stdio.h, and the build is broken.

There is another breakage in util/evsel.c caused by include ordering,
but I didn't fully track down the commit that caused it.

The root cause of all this is an inconsistent definition of _GNU_SOURCE,
so I move the definition into the Makefile so that it is passed to all
invocations of the compiler and used uniformly for all system header
files.  All other #define and #undef of _GNU_SOURCE are removed as they
cause conflicts with the definition passed to the compiler.

All the features.h definitions (_LARGEFILE64_SOURCE _FILE_OFFSET_BITS=64
and _GNU_SOURCE) are needed by the python glue code too, so they are
moved to BASIC_CFLAGS, and the misleading comments about BASIC_CFLAGS
are removed.

This gives me a clean build on x86_64 (fc12) and mips (Debian).

Cc: David Daney <david.daney@cavium.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Joerg Roedel <joerg.roedel@amd.com>
Cc: Namhyung Kim <namhyung.kim@lge.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1326836461-11952-1-git-send-email-ddaney.cavm@gmail.com
Signed-off-by: David Daney <david.daney@cavium.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

Showing 8 changed files with 3 additions and 16 deletions Inline Diff

tools/perf/Makefile
tools/perf/builtin-probe.c
tools/perf/util/probe-event.c
tools/perf/util/symbol.c
tools/perf/util/trace-event-parse.c
tools/perf/util/ui/browsers/hists.c
tools/perf/util/ui/helpline.c
tools/perf/util/util.h

tools/perf/Makefile

Diff comments View file @ 0a84f00

 ifeq ("$(origin O)", "command line")
 	OUTPUT := $(O)/
 endif
 # The default target of this Makefile is...
 all:
 include config/utilities.mak
 ifneq ($(OUTPUT),)
 # check that the output directory actually exists
 OUTDIR := $(shell cd $(OUTPUT) && /bin/pwd)
 $(if $(OUTDIR),, $(error output directory "$(OUTPUT)" does not exist))
 endif
 # Define V to have a more verbose compile.
 #
 # 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.
 $(OUTPUT)PERF-VERSION-FILE: .FORCE-PERF-VERSION-FILE
 	@$(SHELL_PATH) util/PERF-VERSION-GEN $(OUTPUT)
 -include $(OUTPUT)PERF-VERSION-FILE
 uname_M := $(shell uname -m 2>/dev/null || echo not)
 ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/i386/ -e s/sun4u/sparc64/ \
 				  -e s/arm.*/arm/ -e s/sa110/arm/ \
 				  -e s/s390x/s390/ -e s/parisc64/parisc/ \
 				  -e s/ppc.*/powerpc/ -e s/mips.*/mips/ \
 				  -e s/sh[234].*/sh/ )
 CC = $(CROSS_COMPILE)gcc
 AR = $(CROSS_COMPILE)ar
 # Additional ARCH settings for x86
 ifeq ($(ARCH),i386)
         ARCH := x86
 endif
 ifeq ($(ARCH),x86_64)
 	ARCH := x86
 	IS_X86_64 := 0
 	ifeq (, $(findstring m32,$(EXTRA_CFLAGS)))
 		IS_X86_64 := $(shell echo __x86_64__ | ${CC} -E -xc - | tail -n 1)
 	endif
 	ifeq (${IS_X86_64}, 1)
 		RAW_ARCH := x86_64
 		ARCH_CFLAGS := -DARCH_X86_64
 		ARCH_INCLUDE = ../../arch/x86/lib/memcpy_64.S
 	endif
 endif
 # Treat warnings as errors unless directed not to
 ifneq ($(WERROR),0)
 	CFLAGS_WERROR := -Werror
 endif
 #
 # Include saner warnings here, which can catch bugs:
 #
 EXTRA_WARNINGS := -Wformat
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wformat-security
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wformat-y2k
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wshadow
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Winit-self
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wpacked
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wredundant-decls
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wstrict-aliasing=3
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wswitch-default
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wswitch-enum
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wno-system-headers
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wundef
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wwrite-strings
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wbad-function-cast
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wmissing-declarations
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wmissing-prototypes
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wnested-externs
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wold-style-definition
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wstrict-prototypes
 EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wdeclaration-after-statement
 ifeq ("$(origin DEBUG)", "command line")
   PERF_DEBUG = $(DEBUG)
 endif
 ifndef PERF_DEBUG
   CFLAGS_OPTIMIZE = -O6
 endif
 CFLAGS = -fno-omit-frame-pointer -ggdb3 -Wall -Wextra -std=gnu99 $(CFLAGS_WERROR) $(CFLAGS_OPTIMIZE) -D_FORTIFY_SOURCE=2 $(EXTRA_WARNINGS) $(EXTRA_CFLAGS)
 EXTLIBS = -lpthread -lrt -lelf -lm
-ALL_CFLAGS = $(CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64
+ALL_CFLAGS = $(CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
 ALL_LDFLAGS = $(LDFLAGS)
 STRIP ?= strip
 # Among the variables below, these:
 #   perfexecdir
 #   template_dir
 #   mandir
 #   infodir
 #   htmldir
 #   ETC_PERFCONFIG (but not sysconfdir)
 # can be specified as a relative path some/where/else;
 # this is interpreted as relative to $(prefix) and "perf" at
 # runtime figures out where they are based on the path to the executable.
 # This can help installing the suite in a relocatable way.
 # Make the path relative to DESTDIR, not to prefix
 ifndef DESTDIR
 prefix = $(HOME)
 endif
 bindir_relative = bin
 bindir = $(prefix)/$(bindir_relative)
 mandir = share/man
 infodir = share/info
 perfexecdir = libexec/perf-core
 sharedir = $(prefix)/share
 template_dir = share/perf-core/templates
 htmldir = share/doc/perf-doc
 ifeq ($(prefix),/usr)
 sysconfdir = /etc
 ETC_PERFCONFIG = $(sysconfdir)/perfconfig
 else
 sysconfdir = $(prefix)/etc
 ETC_PERFCONFIG = etc/perfconfig
 endif
 lib = lib
 export prefix bindir sharedir sysconfdir
 RM = rm -f
 MKDIR = mkdir
 FIND = find
 INSTALL = install
 # 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__
 -include config/feature-tests.mak
 ifeq ($(call try-cc,$(SOURCE_HELLO),-Werror -fstack-protector-all),y)
 	CFLAGS := $(CFLAGS) -fstack-protector-all
 endif
 ifeq ($(call try-cc,$(SOURCE_HELLO),-Werror -Wstack-protector),y)
        CFLAGS := $(CFLAGS) -Wstack-protector
 endif
 ifeq ($(call try-cc,$(SOURCE_HELLO),-Werror -Wvolatile-register-var),y)
        CFLAGS := $(CFLAGS) -Wvolatile-register-var
 endif
 ### --- END CONFIGURATION SECTION ---
-# Those must not be GNU-specific; they are shared with perl/ which may
+BASIC_CFLAGS = -Iutil/include -Iarch/$(ARCH)/include -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
-# be built by a different compiler. (Note that this is an artifact now
-# but it still might be nice to keep that distinction.)
-BASIC_CFLAGS = -Iutil/include -Iarch/$(ARCH)/include
 BASIC_LDFLAGS =
 # 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))
 $(OUTPUT)python/perf.so: $(PYRF_OBJS)
 	$(QUIET_GEN)CFLAGS='$(BASIC_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
 LANG_BINDINGS =
 # 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
 LIB_FILE=$(OUTPUT)libperf.a
 LIB_H += ../../include/linux/perf_event.h
 LIB_H += ../../include/linux/rbtree.h
 LIB_H += ../../include/linux/list.h
 LIB_H += ../../include/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/module.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/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 += 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/debugfs.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/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/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_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/debugfs.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/symbol.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/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/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
 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
 endif
 BUILTIN_OBJS += $(OUTPUT)bench/mem-memcpy.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-test.o
 BUILTIN_OBJS += $(OUTPUT)builtin-inject.o
 PERFLIBS = $(LIB_FILE)
 # Files needed for the python binding, perf.so
 # pyrf is just an internal name needed for all those wrappers.
 # This has to be in sync with what is in the 'sources' variable in
 # tools/perf/util/setup.py
 PYRF_OBJS += $(OUTPUT)util/cpumap.o
 PYRF_OBJS += $(OUTPUT)util/ctype.o
 PYRF_OBJS += $(OUTPUT)util/evlist.o
 PYRF_OBJS += $(OUTPUT)util/evsel.o
 PYRF_OBJS += $(OUTPUT)util/python.o
 PYRF_OBJS += $(OUTPUT)util/thread_map.o
 PYRF_OBJS += $(OUTPUT)util/util.o
 PYRF_OBJS += $(OUTPUT)util/xyarray.o
 #
 # Platform specific tweaks
 #
 # 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 config.mak.autogen
 -include config.mak
 ifndef NO_DWARF
 FLAGS_DWARF=$(ALL_CFLAGS) -ldw -lelf $(ALL_LDFLAGS) $(EXTLIBS)
 ifneq ($(call try-cc,$(SOURCE_DWARF),$(FLAGS_DWARF)),y)
 	msg := $(warning No libdw.h found or old libdw.h found or elfutils is older than 0.138, disables dwarf support. Please install new elfutils-devel/libdw-dev);
 	NO_DWARF := 1
 endif # Dwarf support
 endif # NO_DWARF
 -include arch/$(ARCH)/Makefile
 ifneq ($(OUTPUT),)
 	BASIC_CFLAGS += -I$(OUTPUT)
 endif
 FLAGS_LIBELF=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS)
 ifneq ($(call try-cc,$(SOURCE_LIBELF),$(FLAGS_LIBELF)),y)
 	FLAGS_GLIBC=$(ALL_CFLAGS) $(ALL_LDFLAGS)
 	ifneq ($(call try-cc,$(SOURCE_GLIBC),$(FLAGS_GLIBC)),y)
 		msg := $(error No gnu/libc-version.h found, please install glibc-dev[el]/glibc-static);
 	else
 		msg := $(error No libelf.h/libelf found, please install libelf-dev/elfutils-libelf-devel);
 	endif
 endif
 ifneq ($(call try-cc,$(SOURCE_ELF_MMAP),$(FLAGS_COMMON)),y)
 	BASIC_CFLAGS += -DLIBELF_NO_MMAP
 endif
 ifndef NO_DWARF
 ifeq ($(origin PERF_HAVE_DWARF_REGS), undefined)
 	msg := $(warning DWARF register mappings have not been defined for architecture $(ARCH), DWARF support disabled);
 else
 	BASIC_CFLAGS += -DDWARF_SUPPORT
 	EXTLIBS += -lelf -ldw
 	LIB_OBJS += $(OUTPUT)util/probe-finder.o
 	LIB_OBJS += $(OUTPUT)util/dwarf-aux.o
 endif # PERF_HAVE_DWARF_REGS
 endif # NO_DWARF
 ifdef NO_NEWT
 	BASIC_CFLAGS += -DNO_NEWT_SUPPORT
 else
 	FLAGS_NEWT=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) -lnewt
 	ifneq ($(call try-cc,$(SOURCE_NEWT),$(FLAGS_NEWT)),y)
 		msg := $(warning newt not found, disables TUI support. Please install newt-devel or libnewt-dev);
 		BASIC_CFLAGS += -DNO_NEWT_SUPPORT
 	else
 		# Fedora has /usr/include/slang/slang.h, but ubuntu /usr/include/slang.h
 		BASIC_CFLAGS += -I/usr/include/slang
 		EXTLIBS += -lnewt -lslang
 		LIB_OBJS += $(OUTPUT)util/ui/setup.o
 		LIB_OBJS += $(OUTPUT)util/ui/browser.o
 		LIB_OBJS += $(OUTPUT)util/ui/browsers/annotate.o
 		LIB_OBJS += $(OUTPUT)util/ui/browsers/hists.o
 		LIB_OBJS += $(OUTPUT)util/ui/browsers/map.o
 		LIB_OBJS += $(OUTPUT)util/ui/helpline.o
 		LIB_OBJS += $(OUTPUT)util/ui/progress.o
 		LIB_OBJS += $(OUTPUT)util/ui/util.o
 		LIB_H += util/ui/browser.h
 		LIB_H += util/ui/browsers/map.h
 		LIB_H += util/ui/helpline.h
 		LIB_H += util/ui/keysyms.h
 		LIB_H += util/ui/libslang.h
 		LIB_H += util/ui/progress.h
 		LIB_H += util/ui/util.h
 		LIB_H += util/ui/ui.h
 	endif
 endif
 ifdef NO_LIBPERL
 	BASIC_CFLAGS += -DNO_LIBPERL
 else
        PERL_EMBED_LDOPTS = $(shell perl -MExtUtils::Embed -e ldopts 2>/dev/null)
        PERL_EMBED_LDFLAGS = $(call strip-libs,$(PERL_EMBED_LDOPTS))
        PERL_EMBED_LIBADD = $(call grep-libs,$(PERL_EMBED_LDOPTS))
 	PERL_EMBED_CCOPTS = `perl -MExtUtils::Embed -e ccopts 2>/dev/null`
 	FLAGS_PERL_EMBED=$(PERL_EMBED_CCOPTS) $(PERL_EMBED_LDOPTS)
 	ifneq ($(call try-cc,$(SOURCE_PERL_EMBED),$(FLAGS_PERL_EMBED)),y)
 		BASIC_CFLAGS += -DNO_LIBPERL
 	else
                ALL_LDFLAGS += $(PERL_EMBED_LDFLAGS)
                EXTLIBS += $(PERL_EMBED_LIBADD)
 		LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-perl.o
 		LIB_OBJS += $(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o
 	endif
 endif
 disable-python = $(eval $(disable-python_code))
 define disable-python_code
   BASIC_CFLAGS += -DNO_LIBPYTHON
   $(if $(1),$(warning No $(1) was found))
   $(warning Python support won't be built)
 endef
 override PYTHON := \
   $(call get-executable-or-default,PYTHON,python)
 ifndef PYTHON
   $(call disable-python,python interpreter)
   python-clean :=
 else
   PYTHON_WORD := $(call shell-wordify,$(PYTHON))
   # 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
   ifdef NO_LIBPYTHON
     $(call disable-python)
   else
     override PYTHON_CONFIG := \
       $(call get-executable-or-default,PYTHON_CONFIG,$(PYTHON)-config)
     ifndef PYTHON_CONFIG
       $(call disable-python,python-config tool)
     else
       PYTHON_CONFIG_SQ := $(call shell-sq,$(PYTHON_CONFIG))
       PYTHON_EMBED_LDOPTS := $(shell $(PYTHON_CONFIG_SQ) --ldflags 2>/dev/null)
       PYTHON_EMBED_LDFLAGS := $(call strip-libs,$(PYTHON_EMBED_LDOPTS))
       PYTHON_EMBED_LIBADD := $(call grep-libs,$(PYTHON_EMBED_LDOPTS))
       PYTHON_EMBED_CCOPTS := $(shell $(PYTHON_CONFIG_SQ) --cflags 2>/dev/null)
       FLAGS_PYTHON_EMBED := $(PYTHON_EMBED_CCOPTS) $(PYTHON_EMBED_LDOPTS)
       ifneq ($(call try-cc,$(SOURCE_PYTHON_EMBED),$(FLAGS_PYTHON_EMBED)),y)
         $(call disable-python,Python.h (for Python 2.x))
       else
         ifneq ($(call try-cc,$(SOURCE_PYTHON_VERSION),$(FLAGS_PYTHON_EMBED)),y)
           $(warning Python 3 is not yet supported; please set)
           $(warning PYTHON and/or PYTHON_CONFIG appropriately.)
           $(warning If you also have Python 2 installed, then)
           $(warning try something like:)
           $(warning $(and ,))
           $(warning $(and ,)  make PYTHON=python2)
           $(warning $(and ,))
           $(warning Otherwise, disable Python support entirely:)
           $(warning $(and ,))
           $(warning $(and ,)  make NO_LIBPYTHON=1)
           $(warning $(and ,))
           $(error   $(and ,))
         else
           ALL_LDFLAGS += $(PYTHON_EMBED_LDFLAGS)
           EXTLIBS += $(PYTHON_EMBED_LIBADD)
           LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-python.o
           LIB_OBJS += $(OUTPUT)scripts/python/Perf-Trace-Util/Context.o
           LANG_BINDINGS += $(OUTPUT)python/perf.so
         endif
       endif
     endif
   endif
 endif
 ifdef NO_DEMANGLE
 	BASIC_CFLAGS += -DNO_DEMANGLE
 else
         ifdef HAVE_CPLUS_DEMANGLE
 		EXTLIBS += -liberty
 		BASIC_CFLAGS += -DHAVE_CPLUS_DEMANGLE
         else
 		FLAGS_BFD=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) -lbfd
 		has_bfd := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD))
 		ifeq ($(has_bfd),y)
 			EXTLIBS += -lbfd
 		else
 			FLAGS_BFD_IBERTY=$(FLAGS_BFD) -liberty
 			has_bfd_iberty := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD_IBERTY))
 			ifeq ($(has_bfd_iberty),y)
 				EXTLIBS += -lbfd -liberty
 			else
 				FLAGS_BFD_IBERTY_Z=$(FLAGS_BFD_IBERTY) -lz
 				has_bfd_iberty_z := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD_IBERTY_Z))
 				ifeq ($(has_bfd_iberty_z),y)
 					EXTLIBS += -lbfd -liberty -lz
 				else
 					FLAGS_CPLUS_DEMANGLE=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) -liberty
 					has_cplus_demangle := $(call try-cc,$(SOURCE_CPLUS_DEMANGLE),$(FLAGS_CPLUS_DEMANGLE))
 					ifeq ($(has_cplus_demangle),y)
 						EXTLIBS += -liberty
 						BASIC_CFLAGS += -DHAVE_CPLUS_DEMANGLE
 					else
 						msg := $(warning No bfd.h/libbfd found, install binutils-dev[el]/zlib-static to gain symbol demangling)
 						BASIC_CFLAGS += -DNO_DEMANGLE
 					endif
 				endif
 			endif
 		endif
 	endif
 endif
 ifdef NO_STRLCPY
 	BASIC_CFLAGS += -DNO_STRLCPY
 else
 	ifneq ($(call try-cc,$(SOURCE_STRLCPY),),y)
 		BASIC_CFLAGS += -DNO_STRLCPY
 	endif
 endif
 ifneq ($(findstring $(MAKEFLAGS),s),s)
 ifndef V
 	QUIET_CC       = @echo '   ' CC $@;
 	QUIET_AR       = @echo '   ' AR $@;
 	QUIET_LINK     = @echo '   ' LINK $@;
 	QUIET_MKDIR    = @echo '   ' MKDIR $@;
 	QUIET_GEN      = @echo '   ' GEN $@;
 endif
 endif
 ifdef ASCIIDOC8
 	export ASCIIDOC8
 endif
 # Shell quote (do not use $(call) to accommodate ancient setups);
 ETC_PERFCONFIG_SQ = $(subst ','\'',$(ETC_PERFCONFIG))
 DESTDIR_SQ = $(subst ','\'',$(DESTDIR))
 bindir_SQ = $(subst ','\'',$(bindir))
 bindir_relative_SQ = $(subst ','\'',$(bindir_relative))
 mandir_SQ = $(subst ','\'',$(mandir))
 infodir_SQ = $(subst ','\'',$(infodir))
 perfexecdir_SQ = $(subst ','\'',$(perfexecdir))
 template_dir_SQ = $(subst ','\'',$(template_dir))
 htmldir_SQ = $(subst ','\'',$(htmldir))
 prefix_SQ = $(subst ','\'',$(prefix))
 SHELL_PATH_SQ = $(subst ','\'',$(SHELL_PATH))
 LIBS = -Wl,--whole-archive $(PERFLIBS) -Wl,--no-whole-archive -Wl,--start-group $(EXTLIBS) -Wl,--end-group
 ALL_CFLAGS += $(BASIC_CFLAGS)
 ALL_CFLAGS += $(ARCH_CFLAGS)
 ALL_LDFLAGS += $(BASIC_LDFLAGS)
 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) -DPERF_VERSION='"$(PERF_VERSION)"' \
 		'-DPERF_HTML_PATH="$(htmldir_SQ)"' \
 		$(ALL_CFLAGS) -c $(filter %.c,$^) -o $@
 $(OUTPUT)perf: $(OUTPUT)perf.o $(BUILTIN_OBJS) $(PERFLIBS)
 	$(QUIET_LINK)$(CC) $(ALL_CFLAGS) $(ALL_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 $(ALL_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 $(ALL_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
 $(OUTPUT)%.o: %.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
 $(OUTPUT)%.s: %.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -S $(ALL_CFLAGS) $<
 $(OUTPUT)%.o: %.S
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
 $(OUTPUT)util/exec_cmd.o: util/exec_cmd.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) \
 		'-DPERF_EXEC_PATH="$(perfexecdir_SQ)"' \
 		'-DBINDIR="$(bindir_relative_SQ)"' \
 		'-DPREFIX="$(prefix_SQ)"' \
 		$<
 $(OUTPUT)util/config.o: util/config.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 $(OUTPUT)util/ui/browser.o: util/ui/browser.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)util/ui/browsers/annotate.o: util/ui/browsers/annotate.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)util/ui/browsers/hists.o: util/ui/browsers/hists.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)util/ui/browsers/map.o: util/ui/browsers/map.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 $(OUTPUT)util/rbtree.o: ../../lib/rbtree.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 $(OUTPUT)util/scripting-engines/trace-event-perl.o: util/scripting-engines/trace-event-perl.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
 $(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o: scripts/perl/Perf-Trace-Util/Context.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
 $(OUTPUT)util/scripting-engines/trace-event-python.o: util/scripting-engines/trace-event-python.c $(OUTPUT)PERF-CFLAGS
 	$(QUIET_CC)$(CC) -o $@ -c $(ALL_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 $(ALL_CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
 $(OUTPUT)perf-%: %.o $(PERFLIBS)
 	$(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(ALL_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)
 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 '  distclean		- alias to clean'
 	@echo '  clean			- clean all binary objects and build output'
 doc:
 	$(MAKE) -C Documentation all
 man:
 	$(MAKE) -C Documentation man
 html:
 	$(MAKE) -C Documentation html
 info:
 	$(MAKE) -C Documentation info
 pdf:
 	$(MAKE) -C Documentation pdf
 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 ','\'',$(ALL_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 $(ALL_CFLAGS) $(SPARSE_FLAGS) $$i || exit; \
 		done; \
 	else \
 		exit 1; \
 	fi
 ### Installation rules
 ifneq ($(filter /%,$(firstword $(perfexecdir))),)
 perfexec_instdir = $(perfexecdir)
 else
 perfexec_instdir = $(prefix)/$(perfexecdir)
 endif
 perfexec_instdir_SQ = $(subst ','\'',$(perfexec_instdir))
 install: all
 	$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(bindir_SQ)'
 	$(INSTALL) $(OUTPUT)perf '$(DESTDIR_SQ)$(bindir_SQ)'
 	$(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) $(OUTPUT)perf-archive -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
 	$(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'
 	$(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'
 install-python_ext:
 	$(PYTHON_WORD) util/setup.py --quiet install --root='/$(DESTDIR_SQ)'
 install-doc:
 	$(MAKE) -C Documentation install
 install-man:
 	$(MAKE) -C Documentation install-man
 install-html:
 	$(MAKE) -C Documentation install-html
 install-info:
 	$(MAKE) -C Documentation install-info
 install-pdf:
 	$(MAKE) -C Documentation install-pdf
 quick-install-doc:
 	$(MAKE) -C Documentation quick-install
 quick-install-man:
 	$(MAKE) -C Documentation quick-install-man
 quick-install-html:
 	$(MAKE) -C Documentation quick-install-html
 ### Cleaning rules
 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*
 	$(MAKE) -C Documentation/ clean
 	$(RM) $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)PERF-CFLAGS
 	$(python-clean)
 .PHONY: all install clean strip
 .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-probe.c

Diff comments View file @ 0a84f00

 /*
  * builtin-probe.c
  *
  * Builtin probe command: Set up probe events by C expression
  *
  * Written by Masami Hiramatsu <mhiramat@redhat.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  *
  */
-#define _GNU_SOURCE
 #include <sys/utsname.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
-#undef _GNU_SOURCE
 #include "perf.h"
 #include "builtin.h"
 #include "util/util.h"
 #include "util/strlist.h"
 #include "util/strfilter.h"
 #include "util/symbol.h"
 #include "util/debug.h"
 #include "util/debugfs.h"
 #include "util/parse-options.h"
 #include "util/probe-finder.h"
 #include "util/probe-event.h"
 #define DEFAULT_VAR_FILTER "!__k???tab_* & !__crc_*"
 #define DEFAULT_FUNC_FILTER "!_*"
 /* Session management structure */
 static struct {
 	bool list_events;
 	bool force_add;
 	bool show_lines;
 	bool show_vars;
 	bool show_ext_vars;
 	bool show_funcs;
 	bool mod_events;
 	int nevents;
 	struct perf_probe_event events[MAX_PROBES];
 	struct strlist *dellist;
 	struct line_range line_range;
 	const char *target_module;
 	int max_probe_points;
 	struct strfilter *filter;
 } params;
 /* Parse an event definition. Note that any error must die. */
 static int parse_probe_event(const char *str)
 {
 	struct perf_probe_event *pev = &params.events[params.nevents];
 	int ret;
 	pr_debug("probe-definition(%d): %s\n", params.nevents, str);
 	if (++params.nevents == MAX_PROBES) {
 		pr_err("Too many probes (> %d) were specified.", MAX_PROBES);
 		return -1;
 	}
 	/* Parse a perf-probe command into event */
 	ret = parse_perf_probe_command(str, pev);
 	pr_debug("%d arguments\n", pev->nargs);
 	return ret;
 }
 static int parse_probe_event_argv(int argc, const char **argv)
 {
 	int i, len, ret;
 	char *buf;
 	/* Bind up rest arguments */
 	len = 0;
 	for (i = 0; i < argc; i++)
 		len += strlen(argv[i]) + 1;
 	buf = zalloc(len + 1);
 	if (buf == NULL)
 		return -ENOMEM;
 	len = 0;
 	for (i = 0; i < argc; i++)
 		len += sprintf(&buf[len], "%s ", argv[i]);
 	params.mod_events = true;
 	ret = parse_probe_event(buf);
 	free(buf);
 	return ret;
 }
 static int opt_add_probe_event(const struct option *opt __used,
 			      const char *str, int unset __used)
 {
 	if (str) {
 		params.mod_events = true;
 		return parse_probe_event(str);
 	} else
 		return 0;
 }
 static int opt_del_probe_event(const struct option *opt __used,
 			       const char *str, int unset __used)
 {
 	if (str) {
 		params.mod_events = true;
 		if (!params.dellist)
 			params.dellist = strlist__new(true, NULL);
 		strlist__add(params.dellist, str);
 	}
 	return 0;
 }
 #ifdef DWARF_SUPPORT
 static int opt_show_lines(const struct option *opt __used,
 			  const char *str, int unset __used)
 {
 	int ret = 0;
 	if (!str)
 		return 0;
 	if (params.show_lines) {
 		pr_warning("Warning: more than one --line options are"
 			   " detected. Only the first one is valid.\n");
 		return 0;
 	}
 	params.show_lines = true;
 	ret = parse_line_range_desc(str, &params.line_range);
 	INIT_LIST_HEAD(&params.line_range.line_list);
 	return ret;
 }
 static int opt_show_vars(const struct option *opt __used,
 			 const char *str, int unset __used)
 {
 	struct perf_probe_event *pev = &params.events[params.nevents];
 	int ret;
 	if (!str)
 		return 0;
 	ret = parse_probe_event(str);
 	if (!ret && pev->nargs != 0) {
 		pr_err("  Error: '--vars' doesn't accept arguments.\n");
 		return -EINVAL;
 	}
 	params.show_vars = true;
 	return ret;
 }
 #endif
 static int opt_set_filter(const struct option *opt __used,
 			  const char *str, int unset __used)
 {
 	const char *err;
 	if (str) {
 		pr_debug2("Set filter: %s\n", str);
 		if (params.filter)
 			strfilter__delete(params.filter);
 		params.filter = strfilter__new(str, &err);
 		if (!params.filter) {
 			pr_err("Filter parse error at %td.\n", err - str + 1);
 			pr_err("Source: \"%s\"\n", str);
 			pr_err("         %*c\n", (int)(err - str + 1), '^');
 			return -EINVAL;
 		}
 	}
 	return 0;
 }
 static const char * const probe_usage[] = {
 	"perf probe [<options>] 'PROBEDEF' ['PROBEDEF' ...]",
 	"perf probe [<options>] --add 'PROBEDEF' [--add 'PROBEDEF' ...]",
 	"perf probe [<options>] --del '[GROUP:]EVENT' ...",
 	"perf probe --list",
 #ifdef DWARF_SUPPORT
 	"perf probe [<options>] --line 'LINEDESC'",
 	"perf probe [<options>] --vars 'PROBEPOINT'",
 #endif
 	NULL
 };
 static const struct option options[] = {
 	OPT_INCR('v', "verbose", &verbose,
 		    "be more verbose (show parsed arguments, etc)"),
 	OPT_BOOLEAN('l', "list", &params.list_events,
 		    "list up current probe events"),
 	OPT_CALLBACK('d', "del", NULL, "[GROUP:]EVENT", "delete a probe event.",
 		opt_del_probe_event),
 	OPT_CALLBACK('a', "add", NULL,
 #ifdef DWARF_SUPPORT
 		"[EVENT=]FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT"
 		" [[NAME=]ARG ...]",
 #else
 		"[EVENT=]FUNC[+OFF|%return] [[NAME=]ARG ...]",
 #endif
 		"probe point definition, where\n"
 		"\t\tGROUP:\tGroup name (optional)\n"
 		"\t\tEVENT:\tEvent name\n"
 		"\t\tFUNC:\tFunction name\n"
 		"\t\tOFF:\tOffset from function entry (in byte)\n"
 		"\t\t%return:\tPut the probe at function return\n"
 #ifdef DWARF_SUPPORT
 		"\t\tSRC:\tSource code path\n"
 		"\t\tRL:\tRelative line number from function entry.\n"
 		"\t\tAL:\tAbsolute line number in file.\n"
 		"\t\tPT:\tLazy expression of line code.\n"
 		"\t\tARG:\tProbe argument (local variable name or\n"
 		"\t\t\tkprobe-tracer argument format.)\n",
 #else
 		"\t\tARG:\tProbe argument (kprobe-tracer argument format.)\n",
 #endif
 		opt_add_probe_event),
 	OPT_BOOLEAN('f', "force", &params.force_add, "forcibly add events"
 		    " with existing name"),
 #ifdef DWARF_SUPPORT
 	OPT_CALLBACK('L', "line", NULL,
 		     "FUNC[:RLN[+NUM|-RLN2]]|SRC:ALN[+NUM|-ALN2]",
 		     "Show source code lines.", opt_show_lines),
 	OPT_CALLBACK('V', "vars", NULL,
 		     "FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT",
 		     "Show accessible variables on PROBEDEF", opt_show_vars),
 	OPT_BOOLEAN('\0', "externs", &params.show_ext_vars,
 		    "Show external variables too (with --vars only)"),
 	OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
 		   "file", "vmlinux pathname"),
 	OPT_STRING('s', "source", &symbol_conf.source_prefix,
 		   "directory", "path to kernel source"),
 	OPT_STRING('m', "module", &params.target_module,
 		   "modname|path",
 		   "target module name (for online) or path (for offline)"),
 #endif
 	OPT__DRY_RUN(&probe_event_dry_run),
 	OPT_INTEGER('\0', "max-probes", &params.max_probe_points,
 		 "Set how many probe points can be found for a probe."),
 	OPT_BOOLEAN('F', "funcs", &params.show_funcs,
 		    "Show potential probe-able functions."),
 	OPT_CALLBACK('\0', "filter", NULL,
 		     "[!]FILTER", "Set a filter (with --vars/funcs only)\n"
 		     "\t\t\t(default: \"" DEFAULT_VAR_FILTER "\" for --vars,\n"
 		     "\t\t\t \"" DEFAULT_FUNC_FILTER "\" for --funcs)",
 		     opt_set_filter),
 	OPT_END()
 };
 int cmd_probe(int argc, const char **argv, const char *prefix __used)
 {
 	int ret;
 	argc = parse_options(argc, argv, options, probe_usage,
 			     PARSE_OPT_STOP_AT_NON_OPTION);
 	if (argc > 0) {
 		if (strcmp(argv[0], "-") == 0) {
 			pr_warning("  Error: '-' is not supported.\n");
 			usage_with_options(probe_usage, options);
 		}
 		ret = parse_probe_event_argv(argc, argv);
 		if (ret < 0) {
 			pr_err("  Error: Parse Error.  (%d)\n", ret);
 			return ret;
 		}
 	}
 	if (params.max_probe_points == 0)
 		params.max_probe_points = MAX_PROBES;
 	if ((!params.nevents && !params.dellist && !params.list_events &&
 	     !params.show_lines && !params.show_funcs))
 		usage_with_options(probe_usage, options);
 	/*
 	 * Only consider the user's kernel image path if given.
 	 */
 	symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);
 	if (params.list_events) {
 		if (params.mod_events) {
 			pr_err("  Error: Don't use --list with --add/--del.\n");
 			usage_with_options(probe_usage, options);
 		}
 		if (params.show_lines) {
 			pr_err("  Error: Don't use --list with --line.\n");
 			usage_with_options(probe_usage, options);
 		}
 		if (params.show_vars) {
 			pr_err(" Error: Don't use --list with --vars.\n");
 			usage_with_options(probe_usage, options);
 		}
 		if (params.show_funcs) {
 			pr_err("  Error: Don't use --list with --funcs.\n");
 			usage_with_options(probe_usage, options);
 		}
 		ret = show_perf_probe_events();
 		if (ret < 0)
 			pr_err("  Error: Failed to show event list. (%d)\n",
 			       ret);
 		return ret;
 	}
 	if (params.show_funcs) {
 		if (params.nevents != 0 || params.dellist) {
 			pr_err("  Error: Don't use --funcs with"
 			       " --add/--del.\n");
 			usage_with_options(probe_usage, options);
 		}
 		if (params.show_lines) {
 			pr_err("  Error: Don't use --funcs with --line.\n");
 			usage_with_options(probe_usage, options);
 		}
 		if (params.show_vars) {
 			pr_err("  Error: Don't use --funcs with --vars.\n");
 			usage_with_options(probe_usage, options);
 		}
 		if (!params.filter)
 			params.filter = strfilter__new(DEFAULT_FUNC_FILTER,
 						       NULL);
 		ret = show_available_funcs(params.target_module,
 					   params.filter);
 		strfilter__delete(params.filter);
 		if (ret < 0)
 			pr_err("  Error: Failed to show functions."
 			       " (%d)\n", ret);
 		return ret;
 	}
 #ifdef DWARF_SUPPORT
 	if (params.show_lines) {
 		if (params.mod_events) {
 			pr_err("  Error: Don't use --line with"
 			       " --add/--del.\n");
 			usage_with_options(probe_usage, options);
 		}
 		if (params.show_vars) {
 			pr_err(" Error: Don't use --line with --vars.\n");
 			usage_with_options(probe_usage, options);
 		}
 		ret = show_line_range(&params.line_range, params.target_module);
 		if (ret < 0)
 			pr_err("  Error: Failed to show lines. (%d)\n", ret);
 		return ret;
 	}
 	if (params.show_vars) {
 		if (params.mod_events) {
 			pr_err("  Error: Don't use --vars with"
 			       " --add/--del.\n");
 			usage_with_options(probe_usage, options);
 		}
 		if (!params.filter)
 			params.filter = strfilter__new(DEFAULT_VAR_FILTER,
 						       NULL);
 		ret = show_available_vars(params.events, params.nevents,
 					  params.max_probe_points,
 					  params.target_module,
 					  params.filter,
 					  params.show_ext_vars);
 		strfilter__delete(params.filter);
 		if (ret < 0)
 			pr_err("  Error: Failed to show vars. (%d)\n", ret);
 		return ret;
 	}
 #endif
 	if (params.dellist) {
 		ret = del_perf_probe_events(params.dellist);
 		strlist__delete(params.dellist);
 		if (ret < 0) {
 			pr_err("  Error: Failed to delete events. (%d)\n", ret);
 			return ret;
 		}
 	}
 	if (params.nevents) {
 		ret = add_perf_probe_events(params.events, params.nevents,
 					    params.max_probe_points,
 					    params.target_module,
 					    params.force_add);
 		if (ret < 0) {
 			pr_err("  Error: Failed to add events. (%d)\n", ret);
 			return ret;
 		}
 	}
 	return 0;
 }

tools/perf/util/probe-event.c

Diff comments View file @ 0a84f00

 /*
  * probe-event.c : perf-probe definition to probe_events format converter
  *
  * Written by Masami Hiramatsu <mhiramat@redhat.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  *
  */
-#define _GNU_SOURCE
 #include <sys/utsname.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include <limits.h>
 #include <elf.h>
-#undef _GNU_SOURCE
 #include "util.h"
 #include "event.h"
 #include "string.h"
 #include "strlist.h"
 #include "debug.h"
 #include "cache.h"
 #include "color.h"
 #include "symbol.h"
 #include "thread.h"
 #include "debugfs.h"
 #include "trace-event.h"	/* For __unused */
 #include "probe-event.h"
 #include "probe-finder.h"
 #define MAX_CMDLEN 256
 #define MAX_PROBE_ARGS 128
 #define PERFPROBE_GROUP "probe"
 bool probe_event_dry_run;	/* Dry run flag */
 #define semantic_error(msg ...) pr_err("Semantic error :" msg)
 /* If there is no space to write, returns -E2BIG. */
 static int e_snprintf(char *str, size_t size, const char *format, ...)
 	__attribute__((format(printf, 3, 4)));
 static int e_snprintf(char *str, size_t size, const char *format, ...)
 {
 	int ret;
 	va_list ap;
 	va_start(ap, format);
 	ret = vsnprintf(str, size, format, ap);
 	va_end(ap);
 	if (ret >= (int)size)
 		ret = -E2BIG;
 	return ret;
 }
 static char *synthesize_perf_probe_point(struct perf_probe_point *pp);
 static struct machine machine;
 /* Initialize symbol maps and path of vmlinux/modules */
 static int init_vmlinux(void)
 {
 	int ret;
 	symbol_conf.sort_by_name = true;
 	if (symbol_conf.vmlinux_name == NULL)
 		symbol_conf.try_vmlinux_path = true;
 	else
 		pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name);
 	ret = symbol__init();
 	if (ret < 0) {
 		pr_debug("Failed to init symbol map.\n");
 		goto out;
 	}
 	ret = machine__init(&machine, "", HOST_KERNEL_ID);
 	if (ret < 0)
 		goto out;
 	if (machine__create_kernel_maps(&machine) < 0) {
 		pr_debug("machine__create_kernel_maps() failed.\n");
 		goto out;
 	}
 out:
 	if (ret < 0)
 		pr_warning("Failed to init vmlinux path.\n");
 	return ret;
 }
 static struct symbol *__find_kernel_function_by_name(const char *name,
 						     struct map **mapp)
 {
 	return machine__find_kernel_function_by_name(&machine, name, mapp,
 						     NULL);
 }
 static struct map *kernel_get_module_map(const char *module)
 {
 	struct rb_node *nd;
 	struct map_groups *grp = &machine.kmaps;
 	/* A file path -- this is an offline module */
 	if (module && strchr(module, '/'))
 		return machine__new_module(&machine, 0, module);
 	if (!module)
 		module = "kernel";
 	for (nd = rb_first(&grp->maps[MAP__FUNCTION]); nd; nd = rb_next(nd)) {
 		struct map *pos = rb_entry(nd, struct map, rb_node);
 		if (strncmp(pos->dso->short_name + 1, module,
 			    pos->dso->short_name_len - 2) == 0) {
 			return pos;
 		}
 	}
 	return NULL;
 }
 static struct dso *kernel_get_module_dso(const char *module)
 {
 	struct dso *dso;
 	struct map *map;
 	const char *vmlinux_name;
 	if (module) {
 		list_for_each_entry(dso, &machine.kernel_dsos, node) {
 			if (strncmp(dso->short_name + 1, module,
 				    dso->short_name_len - 2) == 0)
 				goto found;
 		}
 		pr_debug("Failed to find module %s.\n", module);
 		return NULL;
 	}
 	map = machine.vmlinux_maps[MAP__FUNCTION];
 	dso = map->dso;
 	vmlinux_name = symbol_conf.vmlinux_name;
 	if (vmlinux_name) {
 		if (dso__load_vmlinux(dso, map, vmlinux_name, NULL) <= 0)
 			return NULL;
 	} else {
 		if (dso__load_vmlinux_path(dso, map, NULL) <= 0) {
 			pr_debug("Failed to load kernel map.\n");
 			return NULL;
 		}
 	}
 found:
 	return dso;
 }
 const char *kernel_get_module_path(const char *module)
 {
 	struct dso *dso = kernel_get_module_dso(module);
 	return (dso) ? dso->long_name : NULL;
 }
 #ifdef DWARF_SUPPORT
 /* Open new debuginfo of given module */
 static struct debuginfo *open_debuginfo(const char *module)
 {
 	const char *path;
 	/* A file path -- this is an offline module */
 	if (module && strchr(module, '/'))
 		path = module;
 	else {
 		path = kernel_get_module_path(module);
 		if (!path) {
 			pr_err("Failed to find path of %s module.\n",
 			       module ?: "kernel");
 			return NULL;
 		}
 	}
 	return debuginfo__new(path);
 }
 /*
  * Convert trace point to probe point with debuginfo
  * Currently only handles kprobes.
  */
 static int kprobe_convert_to_perf_probe(struct probe_trace_point *tp,
 					struct perf_probe_point *pp)
 {
 	struct symbol *sym;
 	struct map *map;
 	u64 addr;
 	int ret = -ENOENT;
 	struct debuginfo *dinfo;
 	sym = __find_kernel_function_by_name(tp->symbol, &map);
 	if (sym) {
 		addr = map->unmap_ip(map, sym->start + tp->offset);
 		pr_debug("try to find %s+%ld@%" PRIx64 "\n", tp->symbol,
 			 tp->offset, addr);
 		dinfo = debuginfo__new_online_kernel(addr);
 		if (dinfo) {
 			ret = debuginfo__find_probe_point(dinfo,
 						 (unsigned long)addr, pp);
 			debuginfo__delete(dinfo);
 		} else {
 			pr_debug("Failed to open debuginfo at 0x%" PRIx64 "\n",
 				 addr);
 			ret = -ENOENT;
 		}
 	}
 	if (ret <= 0) {
 		pr_debug("Failed to find corresponding probes from "
 			 "debuginfo. Use kprobe event information.\n");
 		pp->function = strdup(tp->symbol);
 		if (pp->function == NULL)
 			return -ENOMEM;
 		pp->offset = tp->offset;
 	}
 	pp->retprobe = tp->retprobe;
 	return 0;
 }
 static int add_module_to_probe_trace_events(struct probe_trace_event *tevs,
 					    int ntevs, const char *module)
 {
 	int i, ret = 0;
 	char *tmp;
 	if (!module)
 		return 0;
 	tmp = strrchr(module, '/');
 	if (tmp) {
 		/* This is a module path -- get the module name */
 		module = strdup(tmp + 1);
 		if (!module)
 			return -ENOMEM;
 		tmp = strchr(module, '.');
 		if (tmp)
 			*tmp = '\0';
 		tmp = (char *)module;	/* For free() */
 	}
 	for (i = 0; i < ntevs; i++) {
 		tevs[i].point.module = strdup(module);
 		if (!tevs[i].point.module) {
 			ret = -ENOMEM;
 			break;
 		}
 	}
 	if (tmp)
 		free(tmp);
 	return ret;
 }
 /* Try to find perf_probe_event with debuginfo */
 static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
 					  struct probe_trace_event **tevs,
 					  int max_tevs, const char *module)
 {
 	bool need_dwarf = perf_probe_event_need_dwarf(pev);
 	struct debuginfo *dinfo = open_debuginfo(module);
 	int ntevs, ret = 0;
 	if (!dinfo) {
 		if (need_dwarf) {
 			pr_warning("Failed to open debuginfo file.\n");
 			return -ENOENT;
 		}
 		pr_debug("Could not open debuginfo. Try to use symbols.\n");
 		return 0;
 	}
 	/* Searching trace events corresponding to a probe event */
 	ntevs = debuginfo__find_trace_events(dinfo, pev, tevs, max_tevs);
 	debuginfo__delete(dinfo);
 	if (ntevs > 0) {	/* Succeeded to find trace events */
 		pr_debug("find %d probe_trace_events.\n", ntevs);
 		if (module)
 			ret = add_module_to_probe_trace_events(*tevs, ntevs,
 							       module);
 		return ret < 0 ? ret : ntevs;
 	}
 	if (ntevs == 0)	{	/* No error but failed to find probe point. */
 		pr_warning("Probe point '%s' not found.\n",
 			   synthesize_perf_probe_point(&pev->point));
 		return -ENOENT;
 	}
 	/* Error path : ntevs < 0 */
 	pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
 	if (ntevs == -EBADF) {
 		pr_warning("Warning: No dwarf info found in the vmlinux - "
 			"please rebuild kernel with CONFIG_DEBUG_INFO=y.\n");
 		if (!need_dwarf) {
 			pr_debug("Trying to use symbols.\n");
 			return 0;
 		}
 	}
 	return ntevs;
 }
 /*
  * Find a src file from a DWARF tag path. Prepend optional source path prefix
  * and chop off leading directories that do not exist. Result is passed back as
  * a newly allocated path on success.
  * Return 0 if file was found and readable, -errno otherwise.
  */
 static int get_real_path(const char *raw_path, const char *comp_dir,
 			 char **new_path)
 {
 	const char *prefix = symbol_conf.source_prefix;
 	if (!prefix) {
 		if (raw_path[0] != '/' && comp_dir)
 			/* If not an absolute path, try to use comp_dir */
 			prefix = comp_dir;
 		else {
 			if (access(raw_path, R_OK) == 0) {
 				*new_path = strdup(raw_path);
 				return 0;
 			} else
 				return -errno;
 		}
 	}
 	*new_path = malloc((strlen(prefix) + strlen(raw_path) + 2));
 	if (!*new_path)
 		return -ENOMEM;
 	for (;;) {
 		sprintf(*new_path, "%s/%s", prefix, raw_path);
 		if (access(*new_path, R_OK) == 0)
 			return 0;
 		if (!symbol_conf.source_prefix)
 			/* In case of searching comp_dir, don't retry */
 			return -errno;
 		switch (errno) {
 		case ENAMETOOLONG:
 		case ENOENT:
 		case EROFS:
 		case EFAULT:
 			raw_path = strchr(++raw_path, '/');
 			if (!raw_path) {
 				free(*new_path);
 				*new_path = NULL;
 				return -ENOENT;
 			}
 			continue;
 		default:
 			free(*new_path);
 			*new_path = NULL;
 			return -errno;
 		}
 	}
 }
 #define LINEBUF_SIZE 256
 #define NR_ADDITIONAL_LINES 2
 static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
 {
 	char buf[LINEBUF_SIZE];
 	const char *color = show_num ? "" : PERF_COLOR_BLUE;
 	const char *prefix = NULL;
 	do {
 		if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
 			goto error;
 		if (skip)
 			continue;
 		if (!prefix) {
 			prefix = show_num ? "%7d  " : "         ";
 			color_fprintf(stdout, color, prefix, l);
 		}
 		color_fprintf(stdout, color, "%s", buf);
 	} while (strchr(buf, '\n') == NULL);
 	return 1;
 error:
 	if (ferror(fp)) {
 		pr_warning("File read error: %s\n", strerror(errno));
 		return -1;
 	}
 	return 0;
 }
 static int _show_one_line(FILE *fp, int l, bool skip, bool show_num)
 {
 	int rv = __show_one_line(fp, l, skip, show_num);
 	if (rv == 0) {
 		pr_warning("Source file is shorter than expected.\n");
 		rv = -1;
 	}
 	return rv;
 }
 #define show_one_line_with_num(f,l)	_show_one_line(f,l,false,true)
 #define show_one_line(f,l)		_show_one_line(f,l,false,false)
 #define skip_one_line(f,l)		_show_one_line(f,l,true,false)
 #define show_one_line_or_eof(f,l)	__show_one_line(f,l,false,false)
 /*
  * Show line-range always requires debuginfo to find source file and
  * line number.
  */
 int show_line_range(struct line_range *lr, const char *module)
 {
 	int l = 1;
 	struct line_node *ln;
 	struct debuginfo *dinfo;
 	FILE *fp;
 	int ret;
 	char *tmp;
 	/* Search a line range */
 	ret = init_vmlinux();
 	if (ret < 0)
 		return ret;
 	dinfo = open_debuginfo(module);
 	if (!dinfo) {
 		pr_warning("Failed to open debuginfo file.\n");
 		return -ENOENT;
 	}
 	ret = debuginfo__find_line_range(dinfo, lr);
 	debuginfo__delete(dinfo);
 	if (ret == 0) {
 		pr_warning("Specified source line is not found.\n");
 		return -ENOENT;
 	} else if (ret < 0) {
 		pr_warning("Debuginfo analysis failed. (%d)\n", ret);
 		return ret;
 	}
 	/* Convert source file path */
 	tmp = lr->path;
 	ret = get_real_path(tmp, lr->comp_dir, &lr->path);
 	free(tmp);	/* Free old path */
 	if (ret < 0) {
 		pr_warning("Failed to find source file. (%d)\n", ret);
 		return ret;
 	}
 	setup_pager();
 	if (lr->function)
 		fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path,
 			lr->start - lr->offset);
 	else
 		fprintf(stdout, "<%s:%d>\n", lr->path, lr->start);
 	fp = fopen(lr->path, "r");
 	if (fp == NULL) {
 		pr_warning("Failed to open %s: %s\n", lr->path,
 			   strerror(errno));
 		return -errno;
 	}
 	/* Skip to starting line number */
 	while (l < lr->start) {
 		ret = skip_one_line(fp, l++);
 		if (ret < 0)
 			goto end;
 	}
 	list_for_each_entry(ln, &lr->line_list, list) {
 		for (; ln->line > l; l++) {
 			ret = show_one_line(fp, l - lr->offset);
 			if (ret < 0)
 				goto end;
 		}
 		ret = show_one_line_with_num(fp, l++ - lr->offset);
 		if (ret < 0)
 			goto end;
 	}
 	if (lr->end == INT_MAX)
 		lr->end = l + NR_ADDITIONAL_LINES;
 	while (l <= lr->end) {
 		ret = show_one_line_or_eof(fp, l++ - lr->offset);
 		if (ret <= 0)
 			break;
 	}
 end:
 	fclose(fp);
 	return ret;
 }
 static int show_available_vars_at(struct debuginfo *dinfo,
 				  struct perf_probe_event *pev,
 				  int max_vls, struct strfilter *_filter,
 				  bool externs)
 {
 	char *buf;
 	int ret, i, nvars;
 	struct str_node *node;
 	struct variable_list *vls = NULL, *vl;
 	const char *var;
 	buf = synthesize_perf_probe_point(&pev->point);
 	if (!buf)
 		return -EINVAL;
 	pr_debug("Searching variables at %s\n", buf);
 	ret = debuginfo__find_available_vars_at(dinfo, pev, &vls,
 						max_vls, externs);
 	if (ret <= 0) {
 		pr_err("Failed to find variables at %s (%d)\n", buf, ret);
 		goto end;
 	}
 	/* Some variables are found */
 	fprintf(stdout, "Available variables at %s\n", buf);
 	for (i = 0; i < ret; i++) {
 		vl = &vls[i];
 		/*
 		 * A probe point might be converted to
 		 * several trace points.
 		 */
 		fprintf(stdout, "\t@<%s+%lu>\n", vl->point.symbol,
 			vl->point.offset);
 		free(vl->point.symbol);
 		nvars = 0;
 		if (vl->vars) {
 			strlist__for_each(node, vl->vars) {
 				var = strchr(node->s, '\t') + 1;
 				if (strfilter__compare(_filter, var)) {
 					fprintf(stdout, "\t\t%s\n", node->s);
 					nvars++;
 				}
 			}
 			strlist__delete(vl->vars);
 		}
 		if (nvars == 0)
 			fprintf(stdout, "\t\t(No matched variables)\n");
 	}
 	free(vls);
 end:
 	free(buf);
 	return ret;
 }
 /* Show available variables on given probe point */
 int show_available_vars(struct perf_probe_event *pevs, int npevs,
 			int max_vls, const char *module,
 			struct strfilter *_filter, bool externs)
 {
 	int i, ret = 0;
 	struct debuginfo *dinfo;
 	ret = init_vmlinux();
 	if (ret < 0)
 		return ret;
 	dinfo = open_debuginfo(module);
 	if (!dinfo) {
 		pr_warning("Failed to open debuginfo file.\n");
 		return -ENOENT;
 	}
 	setup_pager();
 	for (i = 0; i < npevs && ret >= 0; i++)
 		ret = show_available_vars_at(dinfo, &pevs[i], max_vls, _filter,
 					     externs);
 	debuginfo__delete(dinfo);
 	return ret;
 }
 #else	/* !DWARF_SUPPORT */
 static int kprobe_convert_to_perf_probe(struct probe_trace_point *tp,
 					struct perf_probe_point *pp)
 {
 	struct symbol *sym;
 	sym = __find_kernel_function_by_name(tp->symbol, NULL);
 	if (!sym) {
 		pr_err("Failed to find symbol %s in kernel.\n", tp->symbol);
 		return -ENOENT;
 	}
 	pp->function = strdup(tp->symbol);
 	if (pp->function == NULL)
 		return -ENOMEM;
 	pp->offset = tp->offset;
 	pp->retprobe = tp->retprobe;
 	return 0;
 }
 static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
 				struct probe_trace_event **tevs __unused,
 				int max_tevs __unused, const char *mod __unused)
 {
 	if (perf_probe_event_need_dwarf(pev)) {
 		pr_warning("Debuginfo-analysis is not supported.\n");
 		return -ENOSYS;
 	}
 	return 0;
 }
 int show_line_range(struct line_range *lr __unused, const char *module __unused)
 {
 	pr_warning("Debuginfo-analysis is not supported.\n");
 	return -ENOSYS;
 }
 int show_available_vars(struct perf_probe_event *pevs __unused,
 			int npevs __unused, int max_vls __unused,
 			const char *module __unused,
 			struct strfilter *filter __unused,
 			bool externs __unused)
 {
 	pr_warning("Debuginfo-analysis is not supported.\n");
 	return -ENOSYS;
 }
 #endif
 static int parse_line_num(char **ptr, int *val, const char *what)
 {
 	const char *start = *ptr;
 	errno = 0;
 	*val = strtol(*ptr, ptr, 0);
 	if (errno || *ptr == start) {
 		semantic_error("'%s' is not a valid number.\n", what);
 		return -EINVAL;
 	}
 	return 0;
 }
 /*
  * Stuff 'lr' according to the line range described by 'arg'.
  * The line range syntax is described by:
  *
  *         SRC[:SLN[+NUM|-ELN]]
  *         FNC[@SRC][:SLN[+NUM|-ELN]]
  */
 int parse_line_range_desc(const char *arg, struct line_range *lr)
 {
 	char *range, *file, *name = strdup(arg);
 	int err;
 	if (!name)
 		return -ENOMEM;
 	lr->start = 0;
 	lr->end = INT_MAX;
 	range = strchr(name, ':');
 	if (range) {
 		*range++ = '\0';
 		err = parse_line_num(&range, &lr->start, "start line");
 		if (err)
 			goto err;
 		if (*range == '+' || *range == '-') {
 			const char c = *range++;
 			err = parse_line_num(&range, &lr->end, "end line");
 			if (err)
 				goto err;
 			if (c == '+') {
 				lr->end += lr->start;
 				/*
 				 * Adjust the number of lines here.
 				 * If the number of lines == 1, the
 				 * the end of line should be equal to
 				 * the start of line.
 				 */
 				lr->end--;
 			}
 		}
 		pr_debug("Line range is %d to %d\n", lr->start, lr->end);
 		err = -EINVAL;
 		if (lr->start > lr->end) {
 			semantic_error("Start line must be smaller"
 				       " than end line.\n");
 			goto err;
 		}
 		if (*range != '\0') {
 			semantic_error("Tailing with invalid str '%s'.\n", range);
 			goto err;
 		}
 	}
 	file = strchr(name, '@');
 	if (file) {
 		*file = '\0';
 		lr->file = strdup(++file);
 		if (lr->file == NULL) {
 			err = -ENOMEM;
 			goto err;
 		}
 		lr->function = name;
 	} else if (strchr(name, '.'))
 		lr->file = name;
 	else
 		lr->function = name;
 	return 0;
 err:
 	free(name);
 	return err;
 }
 /* Check the name is good for event/group */
 static bool check_event_name(const char *name)
 {
 	if (!isalpha(*name) && *name != '_')
 		return false;
 	while (*++name != '\0') {
 		if (!isalpha(*name) && !isdigit(*name) && *name != '_')
 			return false;
 	}
 	return true;
 }
 /* Parse probepoint definition. */
 static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
 {
 	struct perf_probe_point *pp = &pev->point;
 	char *ptr, *tmp;
 	char c, nc = 0;
 	/*
 	 * <Syntax>
 	 * perf probe [EVENT=]SRC[:LN|;PTN]
 	 * perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
 	 *
 	 * TODO:Group name support
 	 */
 	ptr = strpbrk(arg, ";=@+%");
 	if (ptr && *ptr == '=') {	/* Event name */
 		*ptr = '\0';
 		tmp = ptr + 1;
 		if (strchr(arg, ':')) {
 			semantic_error("Group name is not supported yet.\n");
 			return -ENOTSUP;
 		}
 		if (!check_event_name(arg)) {
 			semantic_error("%s is bad for event name -it must "
 				       "follow C symbol-naming rule.\n", arg);
 			return -EINVAL;
 		}
 		pev->event = strdup(arg);
 		if (pev->event == NULL)
 			return -ENOMEM;
 		pev->group = NULL;
 		arg = tmp;
 	}
 	ptr = strpbrk(arg, ";:+@%");
 	if (ptr) {
 		nc = *ptr;
 		*ptr++ = '\0';
 	}
 	tmp = strdup(arg);
 	if (tmp == NULL)
 		return -ENOMEM;
 	/* Check arg is function or file and copy it */
 	if (strchr(tmp, '.'))	/* File */
 		pp->file = tmp;
 	else			/* Function */
 		pp->function = tmp;
 	/* Parse other options */
 	while (ptr) {
 		arg = ptr;
 		c = nc;
 		if (c == ';') {	/* Lazy pattern must be the last part */
 			pp->lazy_line = strdup(arg);
 			if (pp->lazy_line == NULL)
 				return -ENOMEM;
 			break;
 		}
 		ptr = strpbrk(arg, ";:+@%");
 		if (ptr) {
 			nc = *ptr;
 			*ptr++ = '\0';
 		}
 		switch (c) {
 		case ':':	/* Line number */
 			pp->line = strtoul(arg, &tmp, 0);
 			if (*tmp != '\0') {
 				semantic_error("There is non-digit char"
 					       " in line number.\n");
 				return -EINVAL;
 			}
 			break;
 		case '+':	/* Byte offset from a symbol */
 			pp->offset = strtoul(arg, &tmp, 0);
 			if (*tmp != '\0') {
 				semantic_error("There is non-digit character"
 						" in offset.\n");
 				return -EINVAL;
 			}
 			break;
 		case '@':	/* File name */
 			if (pp->file) {
 				semantic_error("SRC@SRC is not allowed.\n");
 				return -EINVAL;
 			}
 			pp->file = strdup(arg);
 			if (pp->file == NULL)
 				return -ENOMEM;
 			break;
 		case '%':	/* Probe places */
 			if (strcmp(arg, "return") == 0) {
 				pp->retprobe = 1;
 			} else {	/* Others not supported yet */
 				semantic_error("%%%s is not supported.\n", arg);
 				return -ENOTSUP;
 			}
 			break;
 		default:	/* Buggy case */
 			pr_err("This program has a bug at %s:%d.\n",
 				__FILE__, __LINE__);
 			return -ENOTSUP;
 			break;
 		}
 	}
 	/* Exclusion check */
 	if (pp->lazy_line && pp->line) {
 		semantic_error("Lazy pattern can't be used with"
 			       " line number.\n");
 		return -EINVAL;
 	}
 	if (pp->lazy_line && pp->offset) {
 		semantic_error("Lazy pattern can't be used with offset.\n");
 		return -EINVAL;
 	}
 	if (pp->line && pp->offset) {
 		semantic_error("Offset can't be used with line number.\n");
 		return -EINVAL;
 	}
 	if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
 		semantic_error("File always requires line number or "
 			       "lazy pattern.\n");
 		return -EINVAL;
 	}
 	if (pp->offset && !pp->function) {
 		semantic_error("Offset requires an entry function.\n");
 		return -EINVAL;
 	}
 	if (pp->retprobe && !pp->function) {
 		semantic_error("Return probe requires an entry function.\n");
 		return -EINVAL;
 	}
 	if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
 		semantic_error("Offset/Line/Lazy pattern can't be used with "
 			       "return probe.\n");
 		return -EINVAL;
 	}
 	pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
 		 pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
 		 pp->lazy_line);
 	return 0;
 }
 /* Parse perf-probe event argument */
 static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
 {
 	char *tmp, *goodname;
 	struct perf_probe_arg_field **fieldp;
 	pr_debug("parsing arg: %s into ", str);
 	tmp = strchr(str, '=');
 	if (tmp) {
 		arg->name = strndup(str, tmp - str);
 		if (arg->name == NULL)
 			return -ENOMEM;
 		pr_debug("name:%s ", arg->name);
 		str = tmp + 1;
 	}
 	tmp = strchr(str, ':');
 	if (tmp) {	/* Type setting */
 		*tmp = '\0';
 		arg->type = strdup(tmp + 1);
 		if (arg->type == NULL)
 			return -ENOMEM;
 		pr_debug("type:%s ", arg->type);
 	}
 	tmp = strpbrk(str, "-.[");
 	if (!is_c_varname(str) || !tmp) {
 		/* A variable, register, symbol or special value */
 		arg->var = strdup(str);
 		if (arg->var == NULL)
 			return -ENOMEM;
 		pr_debug("%s\n", arg->var);
 		return 0;
 	}
 	/* Structure fields or array element */
 	arg->var = strndup(str, tmp - str);
 	if (arg->var == NULL)
 		return -ENOMEM;
 	goodname = arg->var;
 	pr_debug("%s, ", arg->var);
 	fieldp = &arg->field;
 	do {
 		*fieldp = zalloc(sizeof(struct perf_probe_arg_field));
 		if (*fieldp == NULL)
 			return -ENOMEM;
 		if (*tmp == '[') {	/* Array */
 			str = tmp;
 			(*fieldp)->index = strtol(str + 1, &tmp, 0);
 			(*fieldp)->ref = true;
 			if (*tmp != ']' || tmp == str + 1) {
 				semantic_error("Array index must be a"
 						" number.\n");
 				return -EINVAL;
 			}
 			tmp++;
 			if (*tmp == '\0')
 				tmp = NULL;
 		} else {		/* Structure */
 			if (*tmp == '.') {
 				str = tmp + 1;
 				(*fieldp)->ref = false;
 			} else if (tmp[1] == '>') {
 				str = tmp + 2;
 				(*fieldp)->ref = true;
 			} else {
 				semantic_error("Argument parse error: %s\n",
 					       str);
 				return -EINVAL;
 			}
 			tmp = strpbrk(str, "-.[");
 		}
 		if (tmp) {
 			(*fieldp)->name = strndup(str, tmp - str);
 			if ((*fieldp)->name == NULL)
 				return -ENOMEM;
 			if (*str != '[')
 				goodname = (*fieldp)->name;
 			pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
 			fieldp = &(*fieldp)->next;
 		}
 	} while (tmp);
 	(*fieldp)->name = strdup(str);
 	if ((*fieldp)->name == NULL)
 		return -ENOMEM;
 	if (*str != '[')
 		goodname = (*fieldp)->name;
 	pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
 	/* If no name is specified, set the last field name (not array index)*/
 	if (!arg->name) {
 		arg->name = strdup(goodname);
 		if (arg->name == NULL)
 			return -ENOMEM;
 	}
 	return 0;
 }
 /* Parse perf-probe event command */
 int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
 {
 	char **argv;
 	int argc, i, ret = 0;
 	argv = argv_split(cmd, &argc);
 	if (!argv) {
 		pr_debug("Failed to split arguments.\n");
 		return -ENOMEM;
 	}
 	if (argc - 1 > MAX_PROBE_ARGS) {
 		semantic_error("Too many probe arguments (%d).\n", argc - 1);
 		ret = -ERANGE;
 		goto out;
 	}
 	/* Parse probe point */
 	ret = parse_perf_probe_point(argv[0], pev);
 	if (ret < 0)
 		goto out;
 	/* Copy arguments and ensure return probe has no C argument */
 	pev->nargs = argc - 1;
 	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
 	if (pev->args == NULL) {
 		ret = -ENOMEM;
 		goto out;
 	}
 	for (i = 0; i < pev->nargs && ret >= 0; i++) {
 		ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]);
 		if (ret >= 0 &&
 		    is_c_varname(pev->args[i].var) && pev->point.retprobe) {
 			semantic_error("You can't specify local variable for"
 				       " kretprobe.\n");
 			ret = -EINVAL;
 		}
 	}
 out:
 	argv_free(argv);
 	return ret;
 }
 /* Return true if this perf_probe_event requires debuginfo */
 bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
 {
 	int i;
 	if (pev->point.file || pev->point.line || pev->point.lazy_line)
 		return true;
 	for (i = 0; i < pev->nargs; i++)
 		if (is_c_varname(pev->args[i].var))
 			return true;
 	return false;
 }
 /* Parse probe_events event into struct probe_point */
 static int parse_probe_trace_command(const char *cmd,
 				     struct probe_trace_event *tev)
 {
 	struct probe_trace_point *tp = &tev->point;
 	char pr;
 	char *p;
 	int ret, i, argc;
 	char **argv;
 	pr_debug("Parsing probe_events: %s\n", cmd);
 	argv = argv_split(cmd, &argc);
 	if (!argv) {
 		pr_debug("Failed to split arguments.\n");
 		return -ENOMEM;
 	}
 	if (argc < 2) {
 		semantic_error("Too few probe arguments.\n");
 		ret = -ERANGE;
 		goto out;
 	}
 	/* Scan event and group name. */
 	ret = sscanf(argv[0], "%c:%a[^/ \t]/%a[^ \t]",
 		     &pr, (float *)(void *)&tev->group,
 		     (float *)(void *)&tev->event);
 	if (ret != 3) {
 		semantic_error("Failed to parse event name: %s\n", argv[0]);
 		ret = -EINVAL;
 		goto out;
 	}
 	pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
 	tp->retprobe = (pr == 'r');
 	/* Scan module name(if there), function name and offset */
 	p = strchr(argv[1], ':');
 	if (p) {
 		tp->module = strndup(argv[1], p - argv[1]);
 		p++;
 	} else
 		p = argv[1];
 	ret = sscanf(p, "%a[^+]+%lu", (float *)(void *)&tp->symbol,
 		     &tp->offset);
 	if (ret == 1)
 		tp->offset = 0;
 	tev->nargs = argc - 2;
 	tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
 	if (tev->args == NULL) {
 		ret = -ENOMEM;
 		goto out;
 	}
 	for (i = 0; i < tev->nargs; i++) {
 		p = strchr(argv[i + 2], '=');
 		if (p)	/* We don't need which register is assigned. */
 			*p++ = '\0';
 		else
 			p = argv[i + 2];
 		tev->args[i].name = strdup(argv[i + 2]);
 		/* TODO: parse regs and offset */
 		tev->args[i].value = strdup(p);
 		if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
 			ret = -ENOMEM;
 			goto out;
 		}
 	}
 	ret = 0;
 out:
 	argv_free(argv);
 	return ret;
 }
 /* Compose only probe arg */
 int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf, size_t len)
 {
 	struct perf_probe_arg_field *field = pa->field;
 	int ret;
 	char *tmp = buf;
 	if (pa->name && pa->var)
 		ret = e_snprintf(tmp, len, "%s=%s", pa->name, pa->var);
 	else
 		ret = e_snprintf(tmp, len, "%s", pa->name ? pa->name : pa->var);
 	if (ret <= 0)
 		goto error;
 	tmp += ret;
 	len -= ret;
 	while (field) {
 		if (field->name[0] == '[')
 			ret = e_snprintf(tmp, len, "%s", field->name);
 		else
 			ret = e_snprintf(tmp, len, "%s%s",
 					 field->ref ? "->" : ".", field->name);
 		if (ret <= 0)
 			goto error;
 		tmp += ret;
 		len -= ret;
 		field = field->next;
 	}
 	if (pa->type) {
 		ret = e_snprintf(tmp, len, ":%s", pa->type);
 		if (ret <= 0)
 			goto error;
 		tmp += ret;
 		len -= ret;
 	}
 	return tmp - buf;
 error:
 	pr_debug("Failed to synthesize perf probe argument: %s\n",
 		 strerror(-ret));
 	return ret;
 }
 /* Compose only probe point (not argument) */
 static char *synthesize_perf_probe_point(struct perf_probe_point *pp)
 {
 	char *buf, *tmp;
 	char offs[32] = "", line[32] = "", file[32] = "";
 	int ret, len;
 	buf = zalloc(MAX_CMDLEN);
 	if (buf == NULL) {
 		ret = -ENOMEM;
 		goto error;
 	}
 	if (pp->offset) {
 		ret = e_snprintf(offs, 32, "+%lu", pp->offset);
 		if (ret <= 0)
 			goto error;
 	}
 	if (pp->line) {
 		ret = e_snprintf(line, 32, ":%d", pp->line);
 		if (ret <= 0)
 			goto error;
 	}
 	if (pp->file) {
 		tmp = pp->file;
 		len = strlen(tmp);
 		if (len > 30) {
 			tmp = strchr(pp->file + len - 30, '/');
 			tmp = tmp ? tmp + 1 : pp->file + len - 30;
 		}
 		ret = e_snprintf(file, 32, "@%s", tmp);
 		if (ret <= 0)
 			goto error;
 	}
 	if (pp->function)
 		ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s%s", pp->function,
 				 offs, pp->retprobe ? "%return" : "", line,
 				 file);
 	else
 		ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", file, line);
 	if (ret <= 0)
 		goto error;
 	return buf;
 error:
 	pr_debug("Failed to synthesize perf probe point: %s\n",
 		 strerror(-ret));
 	if (buf)
 		free(buf);
 	return NULL;
 }
 #if 0
 char *synthesize_perf_probe_command(struct perf_probe_event *pev)
 {
 	char *buf;
 	int i, len, ret;
 	buf = synthesize_perf_probe_point(&pev->point);
 	if (!buf)
 		return NULL;
 	len = strlen(buf);
 	for (i = 0; i < pev->nargs; i++) {
 		ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
 				 pev->args[i].name);
 		if (ret <= 0) {
 			free(buf);
 			return NULL;
 		}
 		len += ret;
 	}
 	return buf;
 }
 #endif
 static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
 					     char **buf, size_t *buflen,
 					     int depth)
 {
 	int ret;
 	if (ref->next) {
 		depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
 							 buflen, depth + 1);
 		if (depth < 0)
 			goto out;
 	}
 	ret = e_snprintf(*buf, *buflen, "%+ld(", ref->offset);
 	if (ret < 0)
 		depth = ret;
 	else {
 		*buf += ret;
 		*buflen -= ret;
 	}
 out:
 	return depth;
 }
 static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
 				       char *buf, size_t buflen)
 {
 	struct probe_trace_arg_ref *ref = arg->ref;
 	int ret, depth = 0;
 	char *tmp = buf;
 	/* Argument name or separator */
 	if (arg->name)
 		ret = e_snprintf(buf, buflen, " %s=", arg->name);
 	else
 		ret = e_snprintf(buf, buflen, " ");
 	if (ret < 0)
 		return ret;
 	buf += ret;
 	buflen -= ret;
 	/* Special case: @XXX */
 	if (arg->value[0] == '@' && arg->ref)
 			ref = ref->next;
 	/* Dereferencing arguments */
 	if (ref) {
 		depth = __synthesize_probe_trace_arg_ref(ref, &buf,
 							  &buflen, 1);
 		if (depth < 0)
 			return depth;
 	}
 	/* Print argument value */
 	if (arg->value[0] == '@' && arg->ref)
 		ret = e_snprintf(buf, buflen, "%s%+ld", arg->value,
 				 arg->ref->offset);
 	else
 		ret = e_snprintf(buf, buflen, "%s", arg->value);
 	if (ret < 0)
 		return ret;
 	buf += ret;
 	buflen -= ret;
 	/* Closing */
 	while (depth--) {
 		ret = e_snprintf(buf, buflen, ")");
 		if (ret < 0)
 			return ret;
 		buf += ret;
 		buflen -= ret;
 	}
 	/* Print argument type */
 	if (arg->type) {
 		ret = e_snprintf(buf, buflen, ":%s", arg->type);
 		if (ret <= 0)
 			return ret;
 		buf += ret;
 	}
 	return buf - tmp;
 }
 char *synthesize_probe_trace_command(struct probe_trace_event *tev)
 {
 	struct probe_trace_point *tp = &tev->point;
 	char *buf;
 	int i, len, ret;
 	buf = zalloc(MAX_CMDLEN);
 	if (buf == NULL)
 		return NULL;
 	len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s %s%s%s+%lu",
 			 tp->retprobe ? 'r' : 'p',
 			 tev->group, tev->event,
 			 tp->module ?: "", tp->module ? ":" : "",
 			 tp->symbol, tp->offset);
 	if (len <= 0)
 		goto error;
 	for (i = 0; i < tev->nargs; i++) {
 		ret = synthesize_probe_trace_arg(&tev->args[i], buf + len,
 						  MAX_CMDLEN - len);
 		if (ret <= 0)
 			goto error;
 		len += ret;
 	}
 	return buf;
 error:
 	free(buf);
 	return NULL;
 }
 static int convert_to_perf_probe_event(struct probe_trace_event *tev,
 				       struct perf_probe_event *pev)
 {
 	char buf[64] = "";
 	int i, ret;
 	/* Convert event/group name */
 	pev->event = strdup(tev->event);
 	pev->group = strdup(tev->group);
 	if (pev->event == NULL || pev->group == NULL)
 		return -ENOMEM;
 	/* Convert trace_point to probe_point */
 	ret = kprobe_convert_to_perf_probe(&tev->point, &pev->point);
 	if (ret < 0)
 		return ret;
 	/* Convert trace_arg to probe_arg */
 	pev->nargs = tev->nargs;
 	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
 	if (pev->args == NULL)
 		return -ENOMEM;
 	for (i = 0; i < tev->nargs && ret >= 0; i++) {
 		if (tev->args[i].name)
 			pev->args[i].name = strdup(tev->args[i].name);
 		else {
 			ret = synthesize_probe_trace_arg(&tev->args[i],
 							  buf, 64);
 			pev->args[i].name = strdup(buf);
 		}
 		if (pev->args[i].name == NULL && ret >= 0)
 			ret = -ENOMEM;
 	}
 	if (ret < 0)
 		clear_perf_probe_event(pev);
 	return ret;
 }
 void clear_perf_probe_event(struct perf_probe_event *pev)
 {
 	struct perf_probe_point *pp = &pev->point;
 	struct perf_probe_arg_field *field, *next;
 	int i;
 	if (pev->event)
 		free(pev->event);
 	if (pev->group)
 		free(pev->group);
 	if (pp->file)
 		free(pp->file);
 	if (pp->function)
 		free(pp->function);
 	if (pp->lazy_line)
 		free(pp->lazy_line);
 	for (i = 0; i < pev->nargs; i++) {
 		if (pev->args[i].name)
 			free(pev->args[i].name);
 		if (pev->args[i].var)
 			free(pev->args[i].var);
 		if (pev->args[i].type)
 			free(pev->args[i].type);
 		field = pev->args[i].field;
 		while (field) {
 			next = field->next;
 			if (field->name)
 				free(field->name);
 			free(field);
 			field = next;
 		}
 	}
 	if (pev->args)
 		free(pev->args);
 	memset(pev, 0, sizeof(*pev));
 }
 static void clear_probe_trace_event(struct probe_trace_event *tev)
 {
 	struct probe_trace_arg_ref *ref, *next;
 	int i;
 	if (tev->event)
 		free(tev->event);
 	if (tev->group)
 		free(tev->group);
 	if (tev->point.symbol)
 		free(tev->point.symbol);
 	if (tev->point.module)
 		free(tev->point.module);
 	for (i = 0; i < tev->nargs; i++) {
 		if (tev->args[i].name)
 			free(tev->args[i].name);
 		if (tev->args[i].value)
 			free(tev->args[i].value);
 		if (tev->args[i].type)
 			free(tev->args[i].type);
 		ref = tev->args[i].ref;
 		while (ref) {
 			next = ref->next;
 			free(ref);
 			ref = next;
 		}
 	}
 	if (tev->args)
 		free(tev->args);
 	memset(tev, 0, sizeof(*tev));
 }
 static int open_kprobe_events(bool readwrite)
 {
 	char buf[PATH_MAX];
 	const char *__debugfs;
 	int ret;
 	__debugfs = debugfs_find_mountpoint();
 	if (__debugfs == NULL) {
 		pr_warning("Debugfs is not mounted.\n");
 		return -ENOENT;
 	}
 	ret = e_snprintf(buf, PATH_MAX, "%stracing/kprobe_events", __debugfs);
 	if (ret >= 0) {
 		pr_debug("Opening %s write=%d\n", buf, readwrite);
 		if (readwrite && !probe_event_dry_run)
 			ret = open(buf, O_RDWR, O_APPEND);
 		else
 			ret = open(buf, O_RDONLY, 0);
 	}
 	if (ret < 0) {
 		if (errno == ENOENT)
 			pr_warning("kprobe_events file does not exist - please"
 				 " rebuild kernel with CONFIG_KPROBE_EVENT.\n");
 		else
 			pr_warning("Failed to open kprobe_events file: %s\n",
 				   strerror(errno));
 	}
 	return ret;
 }
 /* Get raw string list of current kprobe_events */
 static struct strlist *get_probe_trace_command_rawlist(int fd)
 {
 	int ret, idx;
 	FILE *fp;
 	char buf[MAX_CMDLEN];
 	char *p;
 	struct strlist *sl;
 	sl = strlist__new(true, NULL);
 	fp = fdopen(dup(fd), "r");
 	while (!feof(fp)) {
 		p = fgets(buf, MAX_CMDLEN, fp);
 		if (!p)
 			break;
 		idx = strlen(p) - 1;
 		if (p[idx] == '\n')
 			p[idx] = '\0';
 		ret = strlist__add(sl, buf);
 		if (ret < 0) {
 			pr_debug("strlist__add failed: %s\n", strerror(-ret));
 			strlist__delete(sl);
 			return NULL;
 		}
 	}
 	fclose(fp);
 	return sl;
 }
 /* Show an event */
 static int show_perf_probe_event(struct perf_probe_event *pev)
 {
 	int i, ret;
 	char buf[128];
 	char *place;
 	/* Synthesize only event probe point */
 	place = synthesize_perf_probe_point(&pev->point);
 	if (!place)
 		return -EINVAL;
 	ret = e_snprintf(buf, 128, "%s:%s", pev->group, pev->event);
 	if (ret < 0)
 		return ret;
 	printf("  %-20s (on %s", buf, place);
 	if (pev->nargs > 0) {
 		printf(" with");
 		for (i = 0; i < pev->nargs; i++) {
 			ret = synthesize_perf_probe_arg(&pev->args[i],
 							buf, 128);
 			if (ret < 0)
 				break;
 			printf(" %s", buf);
 		}
 	}
 	printf(")\n");
 	free(place);
 	return ret;
 }
 /* List up current perf-probe events */
 int show_perf_probe_events(void)
 {
 	int fd, ret;
 	struct probe_trace_event tev;
 	struct perf_probe_event pev;
 	struct strlist *rawlist;
 	struct str_node *ent;
 	setup_pager();
 	ret = init_vmlinux();
 	if (ret < 0)
 		return ret;
 	memset(&tev, 0, sizeof(tev));
 	memset(&pev, 0, sizeof(pev));
 	fd = open_kprobe_events(false);
 	if (fd < 0)
 		return fd;
 	rawlist = get_probe_trace_command_rawlist(fd);
 	close(fd);
 	if (!rawlist)
 		return -ENOENT;
 	strlist__for_each(ent, rawlist) {
 		ret = parse_probe_trace_command(ent->s, &tev);
 		if (ret >= 0) {
 			ret = convert_to_perf_probe_event(&tev, &pev);
 			if (ret >= 0)
 				ret = show_perf_probe_event(&pev);
 		}
 		clear_perf_probe_event(&pev);
 		clear_probe_trace_event(&tev);
 		if (ret < 0)
 			break;
 	}
 	strlist__delete(rawlist);
 	return ret;
 }
 /* Get current perf-probe event names */
 static struct strlist *get_probe_trace_event_names(int fd, bool include_group)
 {
 	char buf[128];
 	struct strlist *sl, *rawlist;
 	struct str_node *ent;
 	struct probe_trace_event tev;
 	int ret = 0;
 	memset(&tev, 0, sizeof(tev));
 	rawlist = get_probe_trace_command_rawlist(fd);
 	sl = strlist__new(true, NULL);
 	strlist__for_each(ent, rawlist) {
 		ret = parse_probe_trace_command(ent->s, &tev);
 		if (ret < 0)
 			break;
 		if (include_group) {
 			ret = e_snprintf(buf, 128, "%s:%s", tev.group,
 					tev.event);
 			if (ret >= 0)
 				ret = strlist__add(sl, buf);
 		} else
 			ret = strlist__add(sl, tev.event);
 		clear_probe_trace_event(&tev);
 		if (ret < 0)
 			break;
 	}
 	strlist__delete(rawlist);
 	if (ret < 0) {
 		strlist__delete(sl);
 		return NULL;
 	}
 	return sl;
 }
 static int write_probe_trace_event(int fd, struct probe_trace_event *tev)
 {
 	int ret = 0;
 	char *buf = synthesize_probe_trace_command(tev);
 	if (!buf) {
 		pr_debug("Failed to synthesize probe trace event.\n");
 		return -EINVAL;
 	}
 	pr_debug("Writing event: %s\n", buf);
 	if (!probe_event_dry_run) {
 		ret = write(fd, buf, strlen(buf));
 		if (ret <= 0)
 			pr_warning("Failed to write event: %s\n",
 				   strerror(errno));
 	}
 	free(buf);
 	return ret;
 }
 static int get_new_event_name(char *buf, size_t len, const char *base,
 			      struct strlist *namelist, bool allow_suffix)
 {
 	int i, ret;
 	/* Try no suffix */
 	ret = e_snprintf(buf, len, "%s", base);
 	if (ret < 0) {
 		pr_debug("snprintf() failed: %s\n", strerror(-ret));
 		return ret;
 	}
 	if (!strlist__has_entry(namelist, buf))
 		return 0;
 	if (!allow_suffix) {
 		pr_warning("Error: event \"%s\" already exists. "
 			   "(Use -f to force duplicates.)\n", base);
 		return -EEXIST;
 	}
 	/* Try to add suffix */
 	for (i = 1; i < MAX_EVENT_INDEX; i++) {
 		ret = e_snprintf(buf, len, "%s_%d", base, i);
 		if (ret < 0) {
 			pr_debug("snprintf() failed: %s\n", strerror(-ret));
 			return ret;
 		}
 		if (!strlist__has_entry(namelist, buf))
 			break;
 	}
 	if (i == MAX_EVENT_INDEX) {
 		pr_warning("Too many events are on the same function.\n");
 		ret = -ERANGE;
 	}
 	return ret;
 }
 static int __add_probe_trace_events(struct perf_probe_event *pev,
 				     struct probe_trace_event *tevs,
 				     int ntevs, bool allow_suffix)
 {
 	int i, fd, ret;
 	struct probe_trace_event *tev = NULL;
 	char buf[64];
 	const char *event, *group;
 	struct strlist *namelist;
 	fd = open_kprobe_events(true);
 	if (fd < 0)
 		return fd;
 	/* Get current event names */
 	namelist = get_probe_trace_event_names(fd, false);
 	if (!namelist) {
 		pr_debug("Failed to get current event list.\n");
 		return -EIO;
 	}
 	ret = 0;
 	printf("Add new event%s\n", (ntevs > 1) ? "s:" : ":");
 	for (i = 0; i < ntevs; i++) {
 		tev = &tevs[i];
 		if (pev->event)
 			event = pev->event;
 		else
 			if (pev->point.function)
 				event = pev->point.function;
 			else
 				event = tev->point.symbol;
 		if (pev->group)
 			group = pev->group;
 		else
 			group = PERFPROBE_GROUP;
 		/* Get an unused new event name */
 		ret = get_new_event_name(buf, 64, event,
 					 namelist, allow_suffix);
 		if (ret < 0)
 			break;
 		event = buf;
 		tev->event = strdup(event);
 		tev->group = strdup(group);
 		if (tev->event == NULL || tev->group == NULL) {
 			ret = -ENOMEM;
 			break;
 		}
 		ret = write_probe_trace_event(fd, tev);
 		if (ret < 0)
 			break;
 		/* Add added event name to namelist */
 		strlist__add(namelist, event);
 		/* Trick here - save current event/group */
 		event = pev->event;
 		group = pev->group;
 		pev->event = tev->event;
 		pev->group = tev->group;
 		show_perf_probe_event(pev);
 		/* Trick here - restore current event/group */
 		pev->event = (char *)event;
 		pev->group = (char *)group;
 		/*
 		 * Probes after the first probe which comes from same
 		 * user input are always allowed to add suffix, because
 		 * there might be several addresses corresponding to
 		 * one code line.
 		 */
 		allow_suffix = true;
 	}
 	if (ret >= 0) {
 		/* Show how to use the event. */
 		printf("\nYou can now use it on all perf tools, such as:\n\n");
 		printf("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group,
 			 tev->event);
 	}
 	strlist__delete(namelist);
 	close(fd);
 	return ret;
 }
 static int convert_to_probe_trace_events(struct perf_probe_event *pev,
 					  struct probe_trace_event **tevs,
 					  int max_tevs, const char *module)
 {
 	struct symbol *sym;
 	int ret = 0, i;
 	struct probe_trace_event *tev;
 	/* Convert perf_probe_event with debuginfo */
 	ret = try_to_find_probe_trace_events(pev, tevs, max_tevs, module);
 	if (ret != 0)
 		return ret;	/* Found in debuginfo or got an error */
 	/* Allocate trace event buffer */
 	tev = *tevs = zalloc(sizeof(struct probe_trace_event));
 	if (tev == NULL)
 		return -ENOMEM;
 	/* Copy parameters */
 	tev->point.symbol = strdup(pev->point.function);
 	if (tev->point.symbol == NULL) {
 		ret = -ENOMEM;
 		goto error;
 	}
 	if (module) {
 		tev->point.module = strdup(module);
 		if (tev->point.module == NULL) {
 			ret = -ENOMEM;
 			goto error;
 		}
 	}
 	tev->point.offset = pev->point.offset;
 	tev->point.retprobe = pev->point.retprobe;
 	tev->nargs = pev->nargs;
 	if (tev->nargs) {
 		tev->args = zalloc(sizeof(struct probe_trace_arg)
 				   * tev->nargs);
 		if (tev->args == NULL) {
 			ret = -ENOMEM;
 			goto error;
 		}
 		for (i = 0; i < tev->nargs; i++) {
 			if (pev->args[i].name) {
 				tev->args[i].name = strdup(pev->args[i].name);
 				if (tev->args[i].name == NULL) {
 					ret = -ENOMEM;
 					goto error;
 				}
 			}
 			tev->args[i].value = strdup(pev->args[i].var);
 			if (tev->args[i].value == NULL) {
 				ret = -ENOMEM;
 				goto error;
 			}
 			if (pev->args[i].type) {
 				tev->args[i].type = strdup(pev->args[i].type);
 				if (tev->args[i].type == NULL) {
 					ret = -ENOMEM;
 					goto error;
 				}
 			}
 		}
 	}
 	/* Currently just checking function name from symbol map */
 	sym = __find_kernel_function_by_name(tev->point.symbol, NULL);
 	if (!sym) {
 		pr_warning("Kernel symbol \'%s\' not found.\n",
 			   tev->point.symbol);
 		ret = -ENOENT;
 		goto error;
 	}
 	return 1;
 error:
 	clear_probe_trace_event(tev);
 	free(tev);
 	*tevs = NULL;
 	return ret;
 }
 struct __event_package {
 	struct perf_probe_event		*pev;
 	struct probe_trace_event	*tevs;
 	int				ntevs;
 };
 int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
 			  int max_tevs, const char *module, bool force_add)
 {
 	int i, j, ret;
 	struct __event_package *pkgs;
 	pkgs = zalloc(sizeof(struct __event_package) * npevs);
 	if (pkgs == NULL)
 		return -ENOMEM;
 	/* Init vmlinux path */
 	ret = init_vmlinux();
 	if (ret < 0) {
 		free(pkgs);
 		return ret;
 	}
 	/* Loop 1: convert all events */
 	for (i = 0; i < npevs; i++) {
 		pkgs[i].pev = &pevs[i];
 		/* Convert with or without debuginfo */
 		ret  = convert_to_probe_trace_events(pkgs[i].pev,
 						     &pkgs[i].tevs,
 						     max_tevs,
 						     module);
 		if (ret < 0)
 			goto end;
 		pkgs[i].ntevs = ret;
 	}
 	/* Loop 2: add all events */
 	for (i = 0; i < npevs; i++) {
 		ret = __add_probe_trace_events(pkgs[i].pev, pkgs[i].tevs,
 						pkgs[i].ntevs, force_add);
 		if (ret < 0)
 			break;
 	}
 end:
 	/* Loop 3: cleanup and free trace events  */
 	for (i = 0; i < npevs; i++) {
 		for (j = 0; j < pkgs[i].ntevs; j++)
 			clear_probe_trace_event(&pkgs[i].tevs[j]);
 		free(pkgs[i].tevs);
 	}
 	free(pkgs);
 	return ret;
 }
 static int __del_trace_probe_event(int fd, struct str_node *ent)
 {
 	char *p;
 	char buf[128];
 	int ret;
 	/* Convert from perf-probe event to trace-probe event */
 	ret = e_snprintf(buf, 128, "-:%s", ent->s);
 	if (ret < 0)
 		goto error;
 	p = strchr(buf + 2, ':');
 	if (!p) {
 		pr_debug("Internal error: %s should have ':' but not.\n",
 			 ent->s);
 		ret = -ENOTSUP;
 		goto error;
 	}
 	*p = '/';
 	pr_debug("Writing event: %s\n", buf);
 	ret = write(fd, buf, strlen(buf));
 	if (ret < 0) {
 		ret = -errno;
 		goto error;
 	}
 	printf("Remove event: %s\n", ent->s);
 	return 0;
 error:
 	pr_warning("Failed to delete event: %s\n", strerror(-ret));
 	return ret;
 }
 static int del_trace_probe_event(int fd, const char *group,
 				  const char *event, struct strlist *namelist)
 {
 	char buf[128];
 	struct str_node *ent, *n;
 	int found = 0, ret = 0;
 	ret = e_snprintf(buf, 128, "%s:%s", group, event);
 	if (ret < 0) {
 		pr_err("Failed to copy event.\n");
 		return ret;
 	}
 	if (strpbrk(buf, "*?")) { /* Glob-exp */
 		strlist__for_each_safe(ent, n, namelist)
 			if (strglobmatch(ent->s, buf)) {
 				found++;
 				ret = __del_trace_probe_event(fd, ent);
 				if (ret < 0)
 					break;
 				strlist__remove(namelist, ent);
 			}
 	} else {
 		ent = strlist__find(namelist, buf);
 		if (ent) {
 			found++;
 			ret = __del_trace_probe_event(fd, ent);
 			if (ret >= 0)
 				strlist__remove(namelist, ent);
 		}
 	}
 	if (found == 0 && ret >= 0)
 		pr_info("Info: Event \"%s\" does not exist.\n", buf);
 	return ret;
 }
 int del_perf_probe_events(struct strlist *dellist)
 {
 	int fd, ret = 0;
 	const char *group, *event;
 	char *p, *str;
 	struct str_node *ent;
 	struct strlist *namelist;
 	fd = open_kprobe_events(true);
 	if (fd < 0)
 		return fd;
 	/* Get current event names */
 	namelist = get_probe_trace_event_names(fd, true);
 	if (namelist == NULL)
 		return -EINVAL;
 	strlist__for_each(ent, dellist) {
 		str = strdup(ent->s);
 		if (str == NULL) {
 			ret = -ENOMEM;
 			break;
 		}
 		pr_debug("Parsing: %s\n", str);
 		p = strchr(str, ':');
 		if (p) {
 			group = str;
 			*p = '\0';
 			event = p + 1;
 		} else {
 			group = "*";
 			event = str;
 		}
 		pr_debug("Group: %s, Event: %s\n", group, event);
 		ret = del_trace_probe_event(fd, group, event, namelist);
 		free(str);
 		if (ret < 0)
 			break;
 	}
 	strlist__delete(namelist);
 	close(fd);
 	return ret;
 }
 /* TODO: don't use a global variable for filter ... */
 static struct strfilter *available_func_filter;
 /*
  * If a symbol corresponds to a function with global binding and
  * matches filter return 0. For all others return 1.
  */
 static int filter_available_functions(struct map *map __unused,
 				      struct symbol *sym)
 {
 	if (sym->binding == STB_GLOBAL &&
 	    strfilter__compare(available_func_filter, sym->name))
 		return 0;
 	return 1;
 }
 int show_available_funcs(const char *module, struct strfilter *_filter)
 {
 	struct map *map;
 	int ret;
 	setup_pager();
 	ret = init_vmlinux();
 	if (ret < 0)
 		return ret;
 	map = kernel_get_module_map(module);
 	if (!map) {
 		pr_err("Failed to find %s map.\n", (module) ? : "kernel");
 		return -EINVAL;
 	}
 	available_func_filter = _filter;
 	if (map__load(map, filter_available_functions)) {
 		pr_err("Failed to load map.\n");
 		return -EINVAL;
 	}
 	if (!dso__sorted_by_name(map->dso, map->type))
 		dso__sort_by_name(map->dso, map->type);
 	dso__fprintf_symbols_by_name(map->dso, map->type, stdout);
 	return 0;
 }

tools/perf/util/symbol.c

Diff comments View file @ 0a84f00

-#define _GNU_SOURCE
 #include <ctype.h>
 #include <dirent.h>
 #include <errno.h>
 #include <libgen.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/param.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <inttypes.h>
 #include "build-id.h"
 #include "debug.h"
 #include "symbol.h"
 #include "strlist.h"
 #include <libelf.h>
 #include <gelf.h>
 #include <elf.h>
 #include <limits.h>
 #include <sys/utsname.h>
 #ifndef KSYM_NAME_LEN
 #define KSYM_NAME_LEN 256
 #endif
 #ifndef NT_GNU_BUILD_ID
 #define NT_GNU_BUILD_ID 3
 #endif
 static bool dso__build_id_equal(const struct dso *dso, u8 *build_id);
 static int elf_read_build_id(Elf *elf, void *bf, size_t size);
 static void dsos__add(struct list_head *head, struct dso *dso);
 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
 				symbol_filter_t filter);
 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
 			symbol_filter_t filter);
 static int vmlinux_path__nr_entries;
 static char **vmlinux_path;
 struct symbol_conf symbol_conf = {
 	.exclude_other	  = true,
 	.use_modules	  = true,
 	.try_vmlinux_path = true,
 	.annotate_src	  = true,
 	.symfs            = "",
 };
 int dso__name_len(const struct dso *dso)
 {
 	if (verbose)
 		return dso->long_name_len;
 	return dso->short_name_len;
 }
 bool dso__loaded(const struct dso *dso, enum map_type type)
 {
 	return dso->loaded & (1 << type);
 }
 bool dso__sorted_by_name(const struct dso *dso, enum map_type type)
 {
 	return dso->sorted_by_name & (1 << type);
 }
 static void dso__set_sorted_by_name(struct dso *dso, enum map_type type)
 {
 	dso->sorted_by_name |= (1 << type);
 }
 bool symbol_type__is_a(char symbol_type, enum map_type map_type)
 {
 	symbol_type = toupper(symbol_type);
 	switch (map_type) {
 	case MAP__FUNCTION:
 		return symbol_type == 'T' || symbol_type == 'W';
 	case MAP__VARIABLE:
 		return symbol_type == 'D';
 	default:
 		return false;
 	}
 }
 static int prefix_underscores_count(const char *str)
 {
 	const char *tail = str;
 	while (*tail == '_')
 		tail++;
 	return tail - str;
 }
 #define SYMBOL_A 0
 #define SYMBOL_B 1
 static int choose_best_symbol(struct symbol *syma, struct symbol *symb)
 {
 	s64 a;
 	s64 b;
 	/* Prefer a symbol with non zero length */
 	a = syma->end - syma->start;
 	b = symb->end - symb->start;
 	if ((b == 0) && (a > 0))
 		return SYMBOL_A;
 	else if ((a == 0) && (b > 0))
 		return SYMBOL_B;
 	/* Prefer a non weak symbol over a weak one */
 	a = syma->binding == STB_WEAK;
 	b = symb->binding == STB_WEAK;
 	if (b && !a)
 		return SYMBOL_A;
 	if (a && !b)
 		return SYMBOL_B;
 	/* Prefer a global symbol over a non global one */
 	a = syma->binding == STB_GLOBAL;
 	b = symb->binding == STB_GLOBAL;
 	if (a && !b)
 		return SYMBOL_A;
 	if (b && !a)
 		return SYMBOL_B;
 	/* Prefer a symbol with less underscores */
 	a = prefix_underscores_count(syma->name);
 	b = prefix_underscores_count(symb->name);
 	if (b > a)
 		return SYMBOL_A;
 	else if (a > b)
 		return SYMBOL_B;
 	/* If all else fails, choose the symbol with the longest name */
 	if (strlen(syma->name) >= strlen(symb->name))
 		return SYMBOL_A;
 	else
 		return SYMBOL_B;
 }
 static void symbols__fixup_duplicate(struct rb_root *symbols)
 {
 	struct rb_node *nd;
 	struct symbol *curr, *next;
 	nd = rb_first(symbols);
 	while (nd) {
 		curr = rb_entry(nd, struct symbol, rb_node);
 again:
 		nd = rb_next(&curr->rb_node);
 		next = rb_entry(nd, struct symbol, rb_node);
 		if (!nd)
 			break;
 		if (curr->start != next->start)
 			continue;
 		if (choose_best_symbol(curr, next) == SYMBOL_A) {
 			rb_erase(&next->rb_node, symbols);
 			goto again;
 		} else {
 			nd = rb_next(&curr->rb_node);
 			rb_erase(&curr->rb_node, symbols);
 		}
 	}
 }
 static void symbols__fixup_end(struct rb_root *symbols)
 {
 	struct rb_node *nd, *prevnd = rb_first(symbols);
 	struct symbol *curr, *prev;
 	if (prevnd == NULL)
 		return;
 	curr = rb_entry(prevnd, struct symbol, rb_node);
 	for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 		prev = curr;
 		curr = rb_entry(nd, struct symbol, rb_node);
 		if (prev->end == prev->start && prev->end != curr->start)
 			prev->end = curr->start - 1;
 	}
 	/* Last entry */
 	if (curr->end == curr->start)
 		curr->end = roundup(curr->start, 4096);
 }
 static void __map_groups__fixup_end(struct map_groups *mg, enum map_type type)
 {
 	struct map *prev, *curr;
 	struct rb_node *nd, *prevnd = rb_first(&mg->maps[type]);
 	if (prevnd == NULL)
 		return;
 	curr = rb_entry(prevnd, struct map, rb_node);
 	for (nd = rb_next(prevnd); nd; nd = rb_next(nd)) {
 		prev = curr;
 		curr = rb_entry(nd, struct map, rb_node);
 		prev->end = curr->start - 1;
 	}
 	/*
 	 * We still haven't the actual symbols, so guess the
 	 * last map final address.
 	 */
 	curr->end = ~0ULL;
 }
 static void map_groups__fixup_end(struct map_groups *mg)
 {
 	int i;
 	for (i = 0; i < MAP__NR_TYPES; ++i)
 		__map_groups__fixup_end(mg, i);
 }
 static struct symbol *symbol__new(u64 start, u64 len, u8 binding,
 				  const char *name)
 {
 	size_t namelen = strlen(name) + 1;
 	struct symbol *sym = calloc(1, (symbol_conf.priv_size +
 					sizeof(*sym) + namelen));
 	if (sym == NULL)
 		return NULL;
 	if (symbol_conf.priv_size)
 		sym = ((void *)sym) + symbol_conf.priv_size;
 	sym->start   = start;
 	sym->end     = len ? start + len - 1 : start;
 	sym->binding = binding;
 	sym->namelen = namelen - 1;
 	pr_debug4("%s: %s %#" PRIx64 "-%#" PRIx64 "\n",
 		  __func__, name, start, sym->end);
 	memcpy(sym->name, name, namelen);
 	return sym;
 }
 void symbol__delete(struct symbol *sym)
 {
 	free(((void *)sym) - symbol_conf.priv_size);
 }
 static size_t symbol__fprintf(struct symbol *sym, FILE *fp)
 {
 	return fprintf(fp, " %" PRIx64 "-%" PRIx64 " %c %s\n",
 		       sym->start, sym->end,
 		       sym->binding == STB_GLOBAL ? 'g' :
 		       sym->binding == STB_LOCAL  ? 'l' : 'w',
 		       sym->name);
 }
 void dso__set_long_name(struct dso *dso, char *name)
 {
 	if (name == NULL)
 		return;
 	dso->long_name = name;
 	dso->long_name_len = strlen(name);
 }
 static void dso__set_short_name(struct dso *dso, const char *name)
 {
 	if (name == NULL)
 		return;
 	dso->short_name = name;
 	dso->short_name_len = strlen(name);
 }
 static void dso__set_basename(struct dso *dso)
 {
 	dso__set_short_name(dso, basename(dso->long_name));
 }
 struct dso *dso__new(const char *name)
 {
 	struct dso *dso = calloc(1, sizeof(*dso) + strlen(name) + 1);
 	if (dso != NULL) {
 		int i;
 		strcpy(dso->name, name);
 		dso__set_long_name(dso, dso->name);
 		dso__set_short_name(dso, dso->name);
 		for (i = 0; i < MAP__NR_TYPES; ++i)
 			dso->symbols[i] = dso->symbol_names[i] = RB_ROOT;
 		dso->symtab_type = SYMTAB__NOT_FOUND;
 		dso->loaded = 0;
 		dso->sorted_by_name = 0;
 		dso->has_build_id = 0;
 		dso->kernel = DSO_TYPE_USER;
 		INIT_LIST_HEAD(&dso->node);
 	}
 	return dso;
 }
 static void symbols__delete(struct rb_root *symbols)
 {
 	struct symbol *pos;
 	struct rb_node *next = rb_first(symbols);
 	while (next) {
 		pos = rb_entry(next, struct symbol, rb_node);
 		next = rb_next(&pos->rb_node);
 		rb_erase(&pos->rb_node, symbols);
 		symbol__delete(pos);
 	}
 }
 void dso__delete(struct dso *dso)
 {
 	int i;
 	for (i = 0; i < MAP__NR_TYPES; ++i)
 		symbols__delete(&dso->symbols[i]);
 	if (dso->sname_alloc)
 		free((char *)dso->short_name);
 	if (dso->lname_alloc)
 		free(dso->long_name);
 	free(dso);
 }
 void dso__set_build_id(struct dso *dso, void *build_id)
 {
 	memcpy(dso->build_id, build_id, sizeof(dso->build_id));
 	dso->has_build_id = 1;
 }
 static void symbols__insert(struct rb_root *symbols, struct symbol *sym)
 {
 	struct rb_node **p = &symbols->rb_node;
 	struct rb_node *parent = NULL;
 	const u64 ip = sym->start;
 	struct symbol *s;
 	while (*p != NULL) {
 		parent = *p;
 		s = rb_entry(parent, struct symbol, rb_node);
 		if (ip < s->start)
 			p = &(*p)->rb_left;
 		else
 			p = &(*p)->rb_right;
 	}
 	rb_link_node(&sym->rb_node, parent, p);
 	rb_insert_color(&sym->rb_node, symbols);
 }
 static struct symbol *symbols__find(struct rb_root *symbols, u64 ip)
 {
 	struct rb_node *n;
 	if (symbols == NULL)
 		return NULL;
 	n = symbols->rb_node;
 	while (n) {
 		struct symbol *s = rb_entry(n, struct symbol, rb_node);
 		if (ip < s->start)
 			n = n->rb_left;
 		else if (ip > s->end)
 			n = n->rb_right;
 		else
 			return s;
 	}
 	return NULL;
 }
 struct symbol_name_rb_node {
 	struct rb_node	rb_node;
 	struct symbol	sym;
 };
 static void symbols__insert_by_name(struct rb_root *symbols, struct symbol *sym)
 {
 	struct rb_node **p = &symbols->rb_node;
 	struct rb_node *parent = NULL;
 	struct symbol_name_rb_node *symn, *s;
 	symn = container_of(sym, struct symbol_name_rb_node, sym);
 	while (*p != NULL) {
 		parent = *p;
 		s = rb_entry(parent, struct symbol_name_rb_node, rb_node);
 		if (strcmp(sym->name, s->sym.name) < 0)
 			p = &(*p)->rb_left;
 		else
 			p = &(*p)->rb_right;
 	}
 	rb_link_node(&symn->rb_node, parent, p);
 	rb_insert_color(&symn->rb_node, symbols);
 }
 static void symbols__sort_by_name(struct rb_root *symbols,
 				  struct rb_root *source)
 {
 	struct rb_node *nd;
 	for (nd = rb_first(source); nd; nd = rb_next(nd)) {
 		struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 		symbols__insert_by_name(symbols, pos);
 	}
 }
 static struct symbol *symbols__find_by_name(struct rb_root *symbols,
 					    const char *name)
 {
 	struct rb_node *n;
 	if (symbols == NULL)
 		return NULL;
 	n = symbols->rb_node;
 	while (n) {
 		struct symbol_name_rb_node *s;
 		int cmp;
 		s = rb_entry(n, struct symbol_name_rb_node, rb_node);
 		cmp = strcmp(name, s->sym.name);
 		if (cmp < 0)
 			n = n->rb_left;
 		else if (cmp > 0)
 			n = n->rb_right;
 		else
 			return &s->sym;
 	}
 	return NULL;
 }
 struct symbol *dso__find_symbol(struct dso *dso,
 				enum map_type type, u64 addr)
 {
 	return symbols__find(&dso->symbols[type], addr);
 }
 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
 					const char *name)
 {
 	return symbols__find_by_name(&dso->symbol_names[type], name);
 }
 void dso__sort_by_name(struct dso *dso, enum map_type type)
 {
 	dso__set_sorted_by_name(dso, type);
 	return symbols__sort_by_name(&dso->symbol_names[type],
 				     &dso->symbols[type]);
 }
 int build_id__sprintf(const u8 *build_id, int len, char *bf)
 {
 	char *bid = bf;
 	const u8 *raw = build_id;
 	int i;
 	for (i = 0; i < len; ++i) {
 		sprintf(bid, "%02x", *raw);
 		++raw;
 		bid += 2;
 	}
 	return raw - build_id;
 }
 size_t dso__fprintf_buildid(struct dso *dso, FILE *fp)
 {
 	char sbuild_id[BUILD_ID_SIZE * 2 + 1];
 	build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
 	return fprintf(fp, "%s", sbuild_id);
 }
 size_t dso__fprintf_symbols_by_name(struct dso *dso,
 				    enum map_type type, FILE *fp)
 {
 	size_t ret = 0;
 	struct rb_node *nd;
 	struct symbol_name_rb_node *pos;
 	for (nd = rb_first(&dso->symbol_names[type]); nd; nd = rb_next(nd)) {
 		pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
 		fprintf(fp, "%s\n", pos->sym.name);
 	}
 	return ret;
 }
 size_t dso__fprintf(struct dso *dso, enum map_type type, FILE *fp)
 {
 	struct rb_node *nd;
 	size_t ret = fprintf(fp, "dso: %s (", dso->short_name);
 	if (dso->short_name != dso->long_name)
 		ret += fprintf(fp, "%s, ", dso->long_name);
 	ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type],
 		       dso->loaded ? "" : "NOT ");
 	ret += dso__fprintf_buildid(dso, fp);
 	ret += fprintf(fp, ")\n");
 	for (nd = rb_first(&dso->symbols[type]); nd; nd = rb_next(nd)) {
 		struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
 		ret += symbol__fprintf(pos, fp);
 	}
 	return ret;
 }
 int kallsyms__parse(const char *filename, void *arg,
 		    int (*process_symbol)(void *arg, const char *name,
 					  char type, u64 start, u64 end))
 {
 	char *line = NULL;
 	size_t n;
 	int err = -1;
 	FILE *file = fopen(filename, "r");
 	if (file == NULL)
 		goto out_failure;
 	err = 0;
 	while (!feof(file)) {
 		u64 start;
 		int line_len, len;
 		char symbol_type;
 		char *symbol_name;
 		line_len = getline(&line, &n, file);
 		if (line_len < 0 || !line)
 			break;
 		line[--line_len] = '\0'; /* \n */
 		len = hex2u64(line, &start);
 		len++;
 		if (len + 2 >= line_len)
 			continue;
 		symbol_type = line[len];
 		len += 2;
 		symbol_name = line + len;
 		len = line_len - len;
 		if (len >= KSYM_NAME_LEN) {
 			err = -1;
 			break;
 		}
 		/*
 		 * module symbols are not sorted so we add all
 		 * symbols with zero length and rely on
 		 * symbols__fixup_end() to fix it up.
 		 */
 		err = process_symbol(arg, symbol_name,
 				     symbol_type, start, start);
 		if (err)
 			break;
 	}
 	free(line);
 	fclose(file);
 	return err;
 out_failure:
 	return -1;
 }
 struct process_kallsyms_args {
 	struct map *map;
 	struct dso *dso;
 };
 static u8 kallsyms2elf_type(char type)
 {
 	if (type == 'W')
 		return STB_WEAK;
 	return isupper(type) ? STB_GLOBAL : STB_LOCAL;
 }
 static int map__process_kallsym_symbol(void *arg, const char *name,
 				       char type, u64 start, u64 end)
 {
 	struct symbol *sym;
 	struct process_kallsyms_args *a = arg;
 	struct rb_root *root = &a->dso->symbols[a->map->type];
 	if (!symbol_type__is_a(type, a->map->type))
 		return 0;
 	sym = symbol__new(start, end - start + 1,
 			  kallsyms2elf_type(type), name);
 	if (sym == NULL)
 		return -ENOMEM;
 	/*
 	 * We will pass the symbols to the filter later, in
 	 * map__split_kallsyms, when we have split the maps per module
 	 */
 	symbols__insert(root, sym);
 	return 0;
 }
 /*
  * Loads the function entries in /proc/kallsyms into kernel_map->dso,
  * so that we can in the next step set the symbol ->end address and then
  * call kernel_maps__split_kallsyms.
  */
 static int dso__load_all_kallsyms(struct dso *dso, const char *filename,
 				  struct map *map)
 {
 	struct process_kallsyms_args args = { .map = map, .dso = dso, };
 	return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
 }
 /*
  * Split the symbols into maps, making sure there are no overlaps, i.e. the
  * kernel range is broken in several maps, named [kernel].N, as we don't have
  * the original ELF section names vmlinux have.
  */
 static int dso__split_kallsyms(struct dso *dso, struct map *map,
 			       symbol_filter_t filter)
 {
 	struct map_groups *kmaps = map__kmap(map)->kmaps;
 	struct machine *machine = kmaps->machine;
 	struct map *curr_map = map;
 	struct symbol *pos;
 	int count = 0, moved = 0;
 	struct rb_root *root = &dso->symbols[map->type];
 	struct rb_node *next = rb_first(root);
 	int kernel_range = 0;
 	while (next) {
 		char *module;
 		pos = rb_entry(next, struct symbol, rb_node);
 		next = rb_next(&pos->rb_node);
 		module = strchr(pos->name, '\t');
 		if (module) {
 			if (!symbol_conf.use_modules)
 				goto discard_symbol;
 			*module++ = '\0';
 			if (strcmp(curr_map->dso->short_name, module)) {
 				if (curr_map != map &&
 				    dso->kernel == DSO_TYPE_GUEST_KERNEL &&
 				    machine__is_default_guest(machine)) {
 					/*
 					 * We assume all symbols of a module are
 					 * continuous in * kallsyms, so curr_map
 					 * points to a module and all its
 					 * symbols are in its kmap. Mark it as
 					 * loaded.
 					 */
 					dso__set_loaded(curr_map->dso,
 							curr_map->type);
 				}
 				curr_map = map_groups__find_by_name(kmaps,
 							map->type, module);
 				if (curr_map == NULL) {
 					pr_debug("%s/proc/{kallsyms,modules} "
 					         "inconsistency while looking "
 						 "for \"%s\" module!\n",
 						 machine->root_dir, module);
 					curr_map = map;
 					goto discard_symbol;
 				}
 				if (curr_map->dso->loaded &&
 				    !machine__is_default_guest(machine))
 					goto discard_symbol;
 			}
 			/*
 			 * So that we look just like we get from .ko files,
 			 * i.e. not prelinked, relative to map->start.
 			 */
 			pos->start = curr_map->map_ip(curr_map, pos->start);
 			pos->end   = curr_map->map_ip(curr_map, pos->end);
 		} else if (curr_map != map) {
 			char dso_name[PATH_MAX];
 			struct dso *ndso;
 			if (count == 0) {
 				curr_map = map;
 				goto filter_symbol;
 			}
 			if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 				snprintf(dso_name, sizeof(dso_name),
 					"[guest.kernel].%d",
 					kernel_range++);
 			else
 				snprintf(dso_name, sizeof(dso_name),
 					"[kernel].%d",
 					kernel_range++);
 			ndso = dso__new(dso_name);
 			if (ndso == NULL)
 				return -1;
 			ndso->kernel = dso->kernel;
 			curr_map = map__new2(pos->start, ndso, map->type);
 			if (curr_map == NULL) {
 				dso__delete(ndso);
 				return -1;
 			}
 			curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
 			map_groups__insert(kmaps, curr_map);
 			++kernel_range;
 		}
 filter_symbol:
 		if (filter && filter(curr_map, pos)) {
 discard_symbol:		rb_erase(&pos->rb_node, root);
 			symbol__delete(pos);
 		} else {
 			if (curr_map != map) {
 				rb_erase(&pos->rb_node, root);
 				symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
 				++moved;
 			} else
 				++count;
 		}
 	}
 	if (curr_map != map &&
 	    dso->kernel == DSO_TYPE_GUEST_KERNEL &&
 	    machine__is_default_guest(kmaps->machine)) {
 		dso__set_loaded(curr_map->dso, curr_map->type);
 	}
 	return count + moved;
 }
 static bool symbol__restricted_filename(const char *filename,
 					const char *restricted_filename)
 {
 	bool restricted = false;
 	if (symbol_conf.kptr_restrict) {
 		char *r = realpath(filename, NULL);
 		if (r != NULL) {
 			restricted = strcmp(r, restricted_filename) == 0;
 			free(r);
 			return restricted;
 		}
 	}
 	return restricted;
 }
 int dso__load_kallsyms(struct dso *dso, const char *filename,
 		       struct map *map, symbol_filter_t filter)
 {
 	if (symbol__restricted_filename(filename, "/proc/kallsyms"))
 		return -1;
 	if (dso__load_all_kallsyms(dso, filename, map) < 0)
 		return -1;
 	symbols__fixup_duplicate(&dso->symbols[map->type]);
 	symbols__fixup_end(&dso->symbols[map->type]);
 	if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 		dso->symtab_type = SYMTAB__GUEST_KALLSYMS;
 	else
 		dso->symtab_type = SYMTAB__KALLSYMS;
 	return dso__split_kallsyms(dso, map, filter);
 }
 static int dso__load_perf_map(struct dso *dso, struct map *map,
 			      symbol_filter_t filter)
 {
 	char *line = NULL;
 	size_t n;
 	FILE *file;
 	int nr_syms = 0;
 	file = fopen(dso->long_name, "r");
 	if (file == NULL)
 		goto out_failure;
 	while (!feof(file)) {
 		u64 start, size;
 		struct symbol *sym;
 		int line_len, len;
 		line_len = getline(&line, &n, file);
 		if (line_len < 0)
 			break;
 		if (!line)
 			goto out_failure;
 		line[--line_len] = '\0'; /* \n */
 		len = hex2u64(line, &start);
 		len++;
 		if (len + 2 >= line_len)
 			continue;
 		len += hex2u64(line + len, &size);
 		len++;
 		if (len + 2 >= line_len)
 			continue;
 		sym = symbol__new(start, size, STB_GLOBAL, line + len);
 		if (sym == NULL)
 			goto out_delete_line;
 		if (filter && filter(map, sym))
 			symbol__delete(sym);
 		else {
 			symbols__insert(&dso->symbols[map->type], sym);
 			nr_syms++;
 		}
 	}
 	free(line);
 	fclose(file);
 	return nr_syms;
 out_delete_line:
 	free(line);
 out_failure:
 	return -1;
 }
 /**
  * elf_symtab__for_each_symbol - iterate thru all the symbols
  *
  * @syms: struct elf_symtab instance to iterate
  * @idx: uint32_t idx
  * @sym: GElf_Sym iterator
  */
 #define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
 	for (idx = 0, gelf_getsym(syms, idx, &sym);\
 	     idx < nr_syms; \
 	     idx++, gelf_getsym(syms, idx, &sym))
 static inline uint8_t elf_sym__type(const GElf_Sym *sym)
 {
 	return GELF_ST_TYPE(sym->st_info);
 }
 static inline int elf_sym__is_function(const GElf_Sym *sym)
 {
 	return elf_sym__type(sym) == STT_FUNC &&
 	       sym->st_name != 0 &&
 	       sym->st_shndx != SHN_UNDEF;
 }
 static inline bool elf_sym__is_object(const GElf_Sym *sym)
 {
 	return elf_sym__type(sym) == STT_OBJECT &&
 		sym->st_name != 0 &&
 		sym->st_shndx != SHN_UNDEF;
 }
 static inline int elf_sym__is_label(const GElf_Sym *sym)
 {
 	return elf_sym__type(sym) == STT_NOTYPE &&
 		sym->st_name != 0 &&
 		sym->st_shndx != SHN_UNDEF &&
 		sym->st_shndx != SHN_ABS;
 }
 static inline const char *elf_sec__name(const GElf_Shdr *shdr,
 					const Elf_Data *secstrs)
 {
 	return secstrs->d_buf + shdr->sh_name;
 }
 static inline int elf_sec__is_text(const GElf_Shdr *shdr,
 					const Elf_Data *secstrs)
 {
 	return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
 }
 static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
 				    const Elf_Data *secstrs)
 {
 	return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
 }
 static inline const char *elf_sym__name(const GElf_Sym *sym,
 					const Elf_Data *symstrs)
 {
 	return symstrs->d_buf + sym->st_name;
 }
 static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
 				    GElf_Shdr *shp, const char *name,
 				    size_t *idx)
 {
 	Elf_Scn *sec = NULL;
 	size_t cnt = 1;
 	while ((sec = elf_nextscn(elf, sec)) != NULL) {
 		char *str;
 		gelf_getshdr(sec, shp);
 		str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
 		if (!strcmp(name, str)) {
 			if (idx)
 				*idx = cnt;
 			break;
 		}
 		++cnt;
 	}
 	return sec;
 }
 #define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
 	for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
 	     idx < nr_entries; \
 	     ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
 #define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
 	for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
 	     idx < nr_entries; \
 	     ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
 /*
  * We need to check if we have a .dynsym, so that we can handle the
  * .plt, synthesizing its symbols, that aren't on the symtabs (be it
  * .dynsym or .symtab).
  * And always look at the original dso, not at debuginfo packages, that
  * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
  */
 static int dso__synthesize_plt_symbols(struct  dso *dso, struct map *map,
 				       symbol_filter_t filter)
 {
 	uint32_t nr_rel_entries, idx;
 	GElf_Sym sym;
 	u64 plt_offset;
 	GElf_Shdr shdr_plt;
 	struct symbol *f;
 	GElf_Shdr shdr_rel_plt, shdr_dynsym;
 	Elf_Data *reldata, *syms, *symstrs;
 	Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
 	size_t dynsym_idx;
 	GElf_Ehdr ehdr;
 	char sympltname[1024];
 	Elf *elf;
 	int nr = 0, symidx, fd, err = 0;
 	char name[PATH_MAX];
 	snprintf(name, sizeof(name), "%s%s",
 		 symbol_conf.symfs, dso->long_name);
 	fd = open(name, O_RDONLY);
 	if (fd < 0)
 		goto out;
 	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 	if (elf == NULL)
 		goto out_close;
 	if (gelf_getehdr(elf, &ehdr) == NULL)
 		goto out_elf_end;
 	scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym,
 					 ".dynsym", &dynsym_idx);
 	if (scn_dynsym == NULL)
 		goto out_elf_end;
 	scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
 					  ".rela.plt", NULL);
 	if (scn_plt_rel == NULL) {
 		scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
 						  ".rel.plt", NULL);
 		if (scn_plt_rel == NULL)
 			goto out_elf_end;
 	}
 	err = -1;
 	if (shdr_rel_plt.sh_link != dynsym_idx)
 		goto out_elf_end;
 	if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
 		goto out_elf_end;
 	/*
 	 * Fetch the relocation section to find the idxes to the GOT
 	 * and the symbols in the .dynsym they refer to.
 	 */
 	reldata = elf_getdata(scn_plt_rel, NULL);
 	if (reldata == NULL)
 		goto out_elf_end;
 	syms = elf_getdata(scn_dynsym, NULL);
 	if (syms == NULL)
 		goto out_elf_end;
 	scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
 	if (scn_symstrs == NULL)
 		goto out_elf_end;
 	symstrs = elf_getdata(scn_symstrs, NULL);
 	if (symstrs == NULL)
 		goto out_elf_end;
 	nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
 	plt_offset = shdr_plt.sh_offset;
 	if (shdr_rel_plt.sh_type == SHT_RELA) {
 		GElf_Rela pos_mem, *pos;
 		elf_section__for_each_rela(reldata, pos, pos_mem, idx,
 					   nr_rel_entries) {
 			symidx = GELF_R_SYM(pos->r_info);
 			plt_offset += shdr_plt.sh_entsize;
 			gelf_getsym(syms, symidx, &sym);
 			snprintf(sympltname, sizeof(sympltname),
 				 "%s@plt", elf_sym__name(&sym, symstrs));
 			f = symbol__new(plt_offset, shdr_plt.sh_entsize,
 					STB_GLOBAL, sympltname);
 			if (!f)
 				goto out_elf_end;
 			if (filter && filter(map, f))
 				symbol__delete(f);
 			else {
 				symbols__insert(&dso->symbols[map->type], f);
 				++nr;
 			}
 		}
 	} else if (shdr_rel_plt.sh_type == SHT_REL) {
 		GElf_Rel pos_mem, *pos;
 		elf_section__for_each_rel(reldata, pos, pos_mem, idx,
 					  nr_rel_entries) {
 			symidx = GELF_R_SYM(pos->r_info);
 			plt_offset += shdr_plt.sh_entsize;
 			gelf_getsym(syms, symidx, &sym);
 			snprintf(sympltname, sizeof(sympltname),
 				 "%s@plt", elf_sym__name(&sym, symstrs));
 			f = symbol__new(plt_offset, shdr_plt.sh_entsize,
 					STB_GLOBAL, sympltname);
 			if (!f)
 				goto out_elf_end;
 			if (filter && filter(map, f))
 				symbol__delete(f);
 			else {
 				symbols__insert(&dso->symbols[map->type], f);
 				++nr;
 			}
 		}
 	}
 	err = 0;
 out_elf_end:
 	elf_end(elf);
 out_close:
 	close(fd);
 	if (err == 0)
 		return nr;
 out:
 	pr_debug("%s: problems reading %s PLT info.\n",
 		 __func__, dso->long_name);
 	return 0;
 }
 static bool elf_sym__is_a(GElf_Sym *sym, enum map_type type)
 {
 	switch (type) {
 	case MAP__FUNCTION:
 		return elf_sym__is_function(sym);
 	case MAP__VARIABLE:
 		return elf_sym__is_object(sym);
 	default:
 		return false;
 	}
 }
 static bool elf_sec__is_a(GElf_Shdr *shdr, Elf_Data *secstrs,
 			  enum map_type type)
 {
 	switch (type) {
 	case MAP__FUNCTION:
 		return elf_sec__is_text(shdr, secstrs);
 	case MAP__VARIABLE:
 		return elf_sec__is_data(shdr, secstrs);
 	default:
 		return false;
 	}
 }
 static size_t elf_addr_to_index(Elf *elf, GElf_Addr addr)
 {
 	Elf_Scn *sec = NULL;
 	GElf_Shdr shdr;
 	size_t cnt = 1;
 	while ((sec = elf_nextscn(elf, sec)) != NULL) {
 		gelf_getshdr(sec, &shdr);
 		if ((addr >= shdr.sh_addr) &&
 		    (addr < (shdr.sh_addr + shdr.sh_size)))
 			return cnt;
 		++cnt;
 	}
 	return -1;
 }
 static int dso__load_sym(struct dso *dso, struct map *map, const char *name,
 			 int fd, symbol_filter_t filter, int kmodule,
 			 int want_symtab)
 {
 	struct kmap *kmap = dso->kernel ? map__kmap(map) : NULL;
 	struct map *curr_map = map;
 	struct dso *curr_dso = dso;
 	Elf_Data *symstrs, *secstrs;
 	uint32_t nr_syms;
 	int err = -1;
 	uint32_t idx;
 	GElf_Ehdr ehdr;
 	GElf_Shdr shdr, opdshdr;
 	Elf_Data *syms, *opddata = NULL;
 	GElf_Sym sym;
 	Elf_Scn *sec, *sec_strndx, *opdsec;
 	Elf *elf;
 	int nr = 0;
 	size_t opdidx = 0;
 	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 	if (elf == NULL) {
 		pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
 		goto out_close;
 	}
 	if (gelf_getehdr(elf, &ehdr) == NULL) {
 		pr_debug("%s: cannot get elf header.\n", __func__);
 		goto out_elf_end;
 	}
 	/* Always reject images with a mismatched build-id: */
 	if (dso->has_build_id) {
 		u8 build_id[BUILD_ID_SIZE];
 		if (elf_read_build_id(elf, build_id, BUILD_ID_SIZE) < 0)
 			goto out_elf_end;
 		if (!dso__build_id_equal(dso, build_id))
 			goto out_elf_end;
 	}
 	sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
 	if (sec == NULL) {
 		if (want_symtab)
 			goto out_elf_end;
 		sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
 		if (sec == NULL)
 			goto out_elf_end;
 	}
 	opdsec = elf_section_by_name(elf, &ehdr, &opdshdr, ".opd", &opdidx);
 	if (opdshdr.sh_type != SHT_PROGBITS)
 		opdsec = NULL;
 	if (opdsec)
 		opddata = elf_rawdata(opdsec, NULL);
 	syms = elf_getdata(sec, NULL);
 	if (syms == NULL)
 		goto out_elf_end;
 	sec = elf_getscn(elf, shdr.sh_link);
 	if (sec == NULL)
 		goto out_elf_end;
 	symstrs = elf_getdata(sec, NULL);
 	if (symstrs == NULL)
 		goto out_elf_end;
 	sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
 	if (sec_strndx == NULL)
 		goto out_elf_end;
 	secstrs = elf_getdata(sec_strndx, NULL);
 	if (secstrs == NULL)
 		goto out_elf_end;
 	nr_syms = shdr.sh_size / shdr.sh_entsize;
 	memset(&sym, 0, sizeof(sym));
 	if (dso->kernel == DSO_TYPE_USER) {
 		dso->adjust_symbols = (ehdr.e_type == ET_EXEC ||
 				elf_section_by_name(elf, &ehdr, &shdr,
 						     ".gnu.prelink_undo",
 						     NULL) != NULL);
 	} else {
 		dso->adjust_symbols = 0;
 	}
 	elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
 		struct symbol *f;
 		const char *elf_name = elf_sym__name(&sym, symstrs);
 		char *demangled = NULL;
 		int is_label = elf_sym__is_label(&sym);
 		const char *section_name;
 		if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
 		    strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
 			kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
 		if (!is_label && !elf_sym__is_a(&sym, map->type))
 			continue;
 		/* Reject ARM ELF "mapping symbols": these aren't unique and
 		 * don't identify functions, so will confuse the profile
 		 * output: */
 		if (ehdr.e_machine == EM_ARM) {
 			if (!strcmp(elf_name, "$a") ||
 			    !strcmp(elf_name, "$d") ||
 			    !strcmp(elf_name, "$t"))
 				continue;
 		}
 		if (opdsec && sym.st_shndx == opdidx) {
 			u32 offset = sym.st_value - opdshdr.sh_addr;
 			u64 *opd = opddata->d_buf + offset;
 			sym.st_value = *opd;
 			sym.st_shndx = elf_addr_to_index(elf, sym.st_value);
 		}
 		sec = elf_getscn(elf, sym.st_shndx);
 		if (!sec)
 			goto out_elf_end;
 		gelf_getshdr(sec, &shdr);
 		if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
 			continue;
 		section_name = elf_sec__name(&shdr, secstrs);
 		/* On ARM, symbols for thumb functions have 1 added to
 		 * the symbol address as a flag - remove it */
 		if ((ehdr.e_machine == EM_ARM) &&
 		    (map->type == MAP__FUNCTION) &&
 		    (sym.st_value & 1))
 			--sym.st_value;
 		if (dso->kernel != DSO_TYPE_USER || kmodule) {
 			char dso_name[PATH_MAX];
 			if (strcmp(section_name,
 				   (curr_dso->short_name +
 				    dso->short_name_len)) == 0)
 				goto new_symbol;
 			if (strcmp(section_name, ".text") == 0) {
 				curr_map = map;
 				curr_dso = dso;
 				goto new_symbol;
 			}
 			snprintf(dso_name, sizeof(dso_name),
 				 "%s%s", dso->short_name, section_name);
 			curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
 			if (curr_map == NULL) {
 				u64 start = sym.st_value;
 				if (kmodule)
 					start += map->start + shdr.sh_offset;
 				curr_dso = dso__new(dso_name);
 				if (curr_dso == NULL)
 					goto out_elf_end;
 				curr_dso->kernel = dso->kernel;
 				curr_dso->long_name = dso->long_name;
 				curr_dso->long_name_len = dso->long_name_len;
 				curr_map = map__new2(start, curr_dso,
 						     map->type);
 				if (curr_map == NULL) {
 					dso__delete(curr_dso);
 					goto out_elf_end;
 				}
 				curr_map->map_ip = identity__map_ip;
 				curr_map->unmap_ip = identity__map_ip;
 				curr_dso->symtab_type = dso->symtab_type;
 				map_groups__insert(kmap->kmaps, curr_map);
 				dsos__add(&dso->node, curr_dso);
 				dso__set_loaded(curr_dso, map->type);
 			} else
 				curr_dso = curr_map->dso;
 			goto new_symbol;
 		}
 		if (curr_dso->adjust_symbols) {
 			pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64 " "
 				  "sh_addr: %#" PRIx64 " sh_offset: %#" PRIx64 "\n", __func__,
 				  (u64)sym.st_value, (u64)shdr.sh_addr,
 				  (u64)shdr.sh_offset);
 			sym.st_value -= shdr.sh_addr - shdr.sh_offset;
 		}
 		/*
 		 * We need to figure out if the object was created from C++ sources
 		 * DWARF DW_compile_unit has this, but we don't always have access
 		 * to it...
 		 */
 		demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
 		if (demangled != NULL)
 			elf_name = demangled;
 new_symbol:
 		f = symbol__new(sym.st_value, sym.st_size,
 				GELF_ST_BIND(sym.st_info), elf_name);
 		free(demangled);
 		if (!f)
 			goto out_elf_end;
 		if (filter && filter(curr_map, f))
 			symbol__delete(f);
 		else {
 			symbols__insert(&curr_dso->symbols[curr_map->type], f);
 			nr++;
 		}
 	}
 	/*
 	 * For misannotated, zeroed, ASM function sizes.
 	 */
 	if (nr > 0) {
 		symbols__fixup_duplicate(&dso->symbols[map->type]);
 		symbols__fixup_end(&dso->symbols[map->type]);
 		if (kmap) {
 			/*
 			 * We need to fixup this here too because we create new
 			 * maps here, for things like vsyscall sections.
 			 */
 			__map_groups__fixup_end(kmap->kmaps, map->type);
 		}
 	}
 	err = nr;
 out_elf_end:
 	elf_end(elf);
 out_close:
 	return err;
 }
 static bool dso__build_id_equal(const struct dso *dso, u8 *build_id)
 {
 	return memcmp(dso->build_id, build_id, sizeof(dso->build_id)) == 0;
 }
 bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
 {
 	bool have_build_id = false;
 	struct dso *pos;
 	list_for_each_entry(pos, head, node) {
 		if (with_hits && !pos->hit)
 			continue;
 		if (pos->has_build_id) {
 			have_build_id = true;
 			continue;
 		}
 		if (filename__read_build_id(pos->long_name, pos->build_id,
 					    sizeof(pos->build_id)) > 0) {
 			have_build_id	  = true;
 			pos->has_build_id = true;
 		}
 	}
 	return have_build_id;
 }
 /*
  * Align offset to 4 bytes as needed for note name and descriptor data.
  */
 #define NOTE_ALIGN(n) (((n) + 3) & -4U)
 static int elf_read_build_id(Elf *elf, void *bf, size_t size)
 {
 	int err = -1;
 	GElf_Ehdr ehdr;
 	GElf_Shdr shdr;
 	Elf_Data *data;
 	Elf_Scn *sec;
 	Elf_Kind ek;
 	void *ptr;
 	if (size < BUILD_ID_SIZE)
 		goto out;
 	ek = elf_kind(elf);
 	if (ek != ELF_K_ELF)
 		goto out;
 	if (gelf_getehdr(elf, &ehdr) == NULL) {
 		pr_err("%s: cannot get elf header.\n", __func__);
 		goto out;
 	}
 	sec = elf_section_by_name(elf, &ehdr, &shdr,
 				  ".note.gnu.build-id", NULL);
 	if (sec == NULL) {
 		sec = elf_section_by_name(elf, &ehdr, &shdr,
 					  ".notes", NULL);
 		if (sec == NULL)
 			goto out;
 	}
 	data = elf_getdata(sec, NULL);
 	if (data == NULL)
 		goto out;
 	ptr = data->d_buf;
 	while (ptr < (data->d_buf + data->d_size)) {
 		GElf_Nhdr *nhdr = ptr;
 		size_t namesz = NOTE_ALIGN(nhdr->n_namesz),
 		       descsz = NOTE_ALIGN(nhdr->n_descsz);
 		const char *name;
 		ptr += sizeof(*nhdr);
 		name = ptr;
 		ptr += namesz;
 		if (nhdr->n_type == NT_GNU_BUILD_ID &&
 		    nhdr->n_namesz == sizeof("GNU")) {
 			if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
 				size_t sz = min(size, descsz);
 				memcpy(bf, ptr, sz);
 				memset(bf + sz, 0, size - sz);
 				err = descsz;
 				break;
 			}
 		}
 		ptr += descsz;
 	}
 out:
 	return err;
 }
 int filename__read_build_id(const char *filename, void *bf, size_t size)
 {
 	int fd, err = -1;
 	Elf *elf;
 	if (size < BUILD_ID_SIZE)
 		goto out;
 	fd = open(filename, O_RDONLY);
 	if (fd < 0)
 		goto out;
 	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 	if (elf == NULL) {
 		pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
 		goto out_close;
 	}
 	err = elf_read_build_id(elf, bf, size);
 	elf_end(elf);
 out_close:
 	close(fd);
 out:
 	return err;
 }
 int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
 {
 	int fd, err = -1;
 	if (size < BUILD_ID_SIZE)
 		goto out;
 	fd = open(filename, O_RDONLY);
 	if (fd < 0)
 		goto out;
 	while (1) {
 		char bf[BUFSIZ];
 		GElf_Nhdr nhdr;
 		size_t namesz, descsz;
 		if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
 			break;
 		namesz = NOTE_ALIGN(nhdr.n_namesz);
 		descsz = NOTE_ALIGN(nhdr.n_descsz);
 		if (nhdr.n_type == NT_GNU_BUILD_ID &&
 		    nhdr.n_namesz == sizeof("GNU")) {
 			if (read(fd, bf, namesz) != (ssize_t)namesz)
 				break;
 			if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
 				size_t sz = min(descsz, size);
 				if (read(fd, build_id, sz) == (ssize_t)sz) {
 					memset(build_id + sz, 0, size - sz);
 					err = 0;
 					break;
 				}
 			} else if (read(fd, bf, descsz) != (ssize_t)descsz)
 				break;
 		} else {
 			int n = namesz + descsz;
 			if (read(fd, bf, n) != n)
 				break;
 		}
 	}
 	close(fd);
 out:
 	return err;
 }
 char dso__symtab_origin(const struct dso *dso)
 {
 	static const char origin[] = {
 		[SYMTAB__KALLSYMS]	      = 'k',
 		[SYMTAB__JAVA_JIT]	      = 'j',
 		[SYMTAB__BUILD_ID_CACHE]      = 'B',
 		[SYMTAB__FEDORA_DEBUGINFO]    = 'f',
 		[SYMTAB__UBUNTU_DEBUGINFO]    = 'u',
 		[SYMTAB__BUILDID_DEBUGINFO]   = 'b',
 		[SYMTAB__SYSTEM_PATH_DSO]     = 'd',
 		[SYMTAB__SYSTEM_PATH_KMODULE] = 'K',
 		[SYMTAB__GUEST_KALLSYMS]      =  'g',
 		[SYMTAB__GUEST_KMODULE]	      =  'G',
 	};
 	if (dso == NULL || dso->symtab_type == SYMTAB__NOT_FOUND)
 		return '!';
 	return origin[dso->symtab_type];
 }
 int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
 {
 	int size = PATH_MAX;
 	char *name;
 	int ret = -1;
 	int fd;
 	struct machine *machine;
 	const char *root_dir;
 	int want_symtab;
 	dso__set_loaded(dso, map->type);
 	if (dso->kernel == DSO_TYPE_KERNEL)
 		return dso__load_kernel_sym(dso, map, filter);
 	else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
 		return dso__load_guest_kernel_sym(dso, map, filter);
 	if (map->groups && map->groups->machine)
 		machine = map->groups->machine;
 	else
 		machine = NULL;
 	name = malloc(size);
 	if (!name)
 		return -1;
 	dso->adjust_symbols = 0;
 	if (strncmp(dso->name, "/tmp/perf-", 10) == 0) {
 		struct stat st;
 		if (lstat(dso->name, &st) < 0)
 			return -1;
 		if (st.st_uid && (st.st_uid != geteuid())) {
 			pr_warning("File %s not owned by current user or root, "
 				"ignoring it.\n", dso->name);
 			return -1;
 		}
 		ret = dso__load_perf_map(dso, map, filter);
 		dso->symtab_type = ret > 0 ? SYMTAB__JAVA_JIT :
 					      SYMTAB__NOT_FOUND;
 		return ret;
 	}
 	/* Iterate over candidate debug images.
 	 * On the first pass, only load images if they have a full symtab.
 	 * Failing that, do a second pass where we accept .dynsym also
 	 */
 	want_symtab = 1;
 restart:
 	for (dso->symtab_type = SYMTAB__BUILD_ID_CACHE;
 	     dso->symtab_type != SYMTAB__NOT_FOUND;
 	     dso->symtab_type++) {
 		switch (dso->symtab_type) {
 		case SYMTAB__BUILD_ID_CACHE:
 			/* skip the locally configured cache if a symfs is given */
 			if (symbol_conf.symfs[0] ||
 			    (dso__build_id_filename(dso, name, size) == NULL)) {
 				continue;
 			}
 			break;
 		case SYMTAB__FEDORA_DEBUGINFO:
 			snprintf(name, size, "%s/usr/lib/debug%s.debug",
 				 symbol_conf.symfs, dso->long_name);
 			break;
 		case SYMTAB__UBUNTU_DEBUGINFO:
 			snprintf(name, size, "%s/usr/lib/debug%s",
 				 symbol_conf.symfs, dso->long_name);
 			break;
 		case SYMTAB__BUILDID_DEBUGINFO: {
 			char build_id_hex[BUILD_ID_SIZE * 2 + 1];
 			if (!dso->has_build_id)
 				continue;
 			build_id__sprintf(dso->build_id,
 					  sizeof(dso->build_id),
 					  build_id_hex);
 			snprintf(name, size,
 				 "%s/usr/lib/debug/.build-id/%.2s/%s.debug",
 				 symbol_conf.symfs, build_id_hex, build_id_hex + 2);
 			}
 			break;
 		case SYMTAB__SYSTEM_PATH_DSO:
 			snprintf(name, size, "%s%s",
 			     symbol_conf.symfs, dso->long_name);
 			break;
 		case SYMTAB__GUEST_KMODULE:
 			if (map->groups && machine)
 				root_dir = machine->root_dir;
 			else
 				root_dir = "";
 			snprintf(name, size, "%s%s%s", symbol_conf.symfs,
 				 root_dir, dso->long_name);
 			break;
 		case SYMTAB__SYSTEM_PATH_KMODULE:
 			snprintf(name, size, "%s%s", symbol_conf.symfs,
 				 dso->long_name);
 			break;
 		default:;
 		}
 		/* Name is now the name of the next image to try */
 		fd = open(name, O_RDONLY);
 		if (fd < 0)
 			continue;
 		ret = dso__load_sym(dso, map, name, fd, filter, 0,
 				    want_symtab);
 		close(fd);
 		/*
 		 * Some people seem to have debuginfo files _WITHOUT_ debug
 		 * info!?!?
 		 */
 		if (!ret)
 			continue;
 		if (ret > 0) {
 			int nr_plt = dso__synthesize_plt_symbols(dso, map,
 								 filter);
 			if (nr_plt > 0)
 				ret += nr_plt;
 			break;
 		}
 	}
 	/*
 	 * If we wanted a full symtab but no image had one,
 	 * relax our requirements and repeat the search.
 	 */
 	if (ret <= 0 && want_symtab) {
 		want_symtab = 0;
 		goto restart;
 	}
 	free(name);
 	if (ret < 0 && strstr(dso->name, " (deleted)") != NULL)
 		return 0;
 	return ret;
 }
 struct map *map_groups__find_by_name(struct map_groups *mg,
 				     enum map_type type, const char *name)
 {
 	struct rb_node *nd;
 	for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) {
 		struct map *map = rb_entry(nd, struct map, rb_node);
 		if (map->dso && strcmp(map->dso->short_name, name) == 0)
 			return map;
 	}
 	return NULL;
 }
 static int dso__kernel_module_get_build_id(struct dso *dso,
 					   const char *root_dir)
 {
 	char filename[PATH_MAX];
 	/*
 	 * kernel module short names are of the form "[module]" and
 	 * we need just "module" here.
 	 */
 	const char *name = dso->short_name + 1;
 	snprintf(filename, sizeof(filename),
 		 "%s/sys/module/%.*s/notes/.note.gnu.build-id",
 		 root_dir, (int)strlen(name) - 1, name);
 	if (sysfs__read_build_id(filename, dso->build_id,
 				 sizeof(dso->build_id)) == 0)
 		dso->has_build_id = true;
 	return 0;
 }
 static int map_groups__set_modules_path_dir(struct map_groups *mg,
 				const char *dir_name)
 {
 	struct dirent *dent;
 	DIR *dir = opendir(dir_name);
 	int ret = 0;
 	if (!dir) {
 		pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
 		return -1;
 	}
 	while ((dent = readdir(dir)) != NULL) {
 		char path[PATH_MAX];
 		struct stat st;
 		/*sshfs might return bad dent->d_type, so we have to stat*/
 		snprintf(path, sizeof(path), "%s/%s", dir_name, dent->d_name);
 		if (stat(path, &st))
 			continue;
 		if (S_ISDIR(st.st_mode)) {
 			if (!strcmp(dent->d_name, ".") ||
 			    !strcmp(dent->d_name, ".."))
 				continue;
 			ret = map_groups__set_modules_path_dir(mg, path);
 			if (ret < 0)
 				goto out;
 		} else {
 			char *dot = strrchr(dent->d_name, '.'),
 			     dso_name[PATH_MAX];
 			struct map *map;
 			char *long_name;
 			if (dot == NULL || strcmp(dot, ".ko"))
 				continue;
 			snprintf(dso_name, sizeof(dso_name), "[%.*s]",
 				 (int)(dot - dent->d_name), dent->d_name);
 			strxfrchar(dso_name, '-', '_');
 			map = map_groups__find_by_name(mg, MAP__FUNCTION,
 						       dso_name);
 			if (map == NULL)
 				continue;
 			long_name = strdup(path);
 			if (long_name == NULL) {
 				ret = -1;
 				goto out;
 			}
 			dso__set_long_name(map->dso, long_name);
 			map->dso->lname_alloc = 1;
 			dso__kernel_module_get_build_id(map->dso, "");
 		}
 	}
 out:
 	closedir(dir);
 	return ret;
 }
 static char *get_kernel_version(const char *root_dir)
 {
 	char version[PATH_MAX];
 	FILE *file;
 	char *name, *tmp;
 	const char *prefix = "Linux version ";
 	sprintf(version, "%s/proc/version", root_dir);
 	file = fopen(version, "r");
 	if (!file)
 		return NULL;
 	version[0] = '\0';
 	tmp = fgets(version, sizeof(version), file);
 	fclose(file);
 	name = strstr(version, prefix);
 	if (!name)
 		return NULL;
 	name += strlen(prefix);
 	tmp = strchr(name, ' ');
 	if (tmp)
 		*tmp = '\0';
 	return strdup(name);
 }
 static int machine__set_modules_path(struct machine *machine)
 {
 	char *version;
 	char modules_path[PATH_MAX];
 	version = get_kernel_version(machine->root_dir);
 	if (!version)
 		return -1;
 	snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel",
 		 machine->root_dir, version);
 	free(version);
 	return map_groups__set_modules_path_dir(&machine->kmaps, modules_path);
 }
 /*
  * Constructor variant for modules (where we know from /proc/modules where
  * they are loaded) and for vmlinux, where only after we load all the
  * symbols we'll know where it starts and ends.
  */
 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
 {
 	struct map *map = calloc(1, (sizeof(*map) +
 				     (dso->kernel ? sizeof(struct kmap) : 0)));
 	if (map != NULL) {
 		/*
 		 * ->end will be filled after we load all the symbols
 		 */
 		map__init(map, type, start, 0, 0, dso);
 	}
 	return map;
 }
 struct map *machine__new_module(struct machine *machine, u64 start,
 				const char *filename)
 {
 	struct map *map;
 	struct dso *dso = __dsos__findnew(&machine->kernel_dsos, filename);
 	if (dso == NULL)
 		return NULL;
 	map = map__new2(start, dso, MAP__FUNCTION);
 	if (map == NULL)
 		return NULL;
 	if (machine__is_host(machine))
 		dso->symtab_type = SYMTAB__SYSTEM_PATH_KMODULE;
 	else
 		dso->symtab_type = SYMTAB__GUEST_KMODULE;
 	map_groups__insert(&machine->kmaps, map);
 	return map;
 }
 static int machine__create_modules(struct machine *machine)
 {
 	char *line = NULL;
 	size_t n;
 	FILE *file;
 	struct map *map;
 	const char *modules;
 	char path[PATH_MAX];
 	if (machine__is_default_guest(machine))
 		modules = symbol_conf.default_guest_modules;
 	else {
 		sprintf(path, "%s/proc/modules", machine->root_dir);
 		modules = path;
 	}
 	if (symbol__restricted_filename(path, "/proc/modules"))
 		return -1;
 	file = fopen(modules, "r");
 	if (file == NULL)
 		return -1;
 	while (!feof(file)) {
 		char name[PATH_MAX];
 		u64 start;
 		char *sep;
 		int line_len;
 		line_len = getline(&line, &n, file);
 		if (line_len < 0)
 			break;
 		if (!line)
 			goto out_failure;
 		line[--line_len] = '\0'; /* \n */
 		sep = strrchr(line, 'x');
 		if (sep == NULL)
 			continue;
 		hex2u64(sep + 1, &start);
 		sep = strchr(line, ' ');
 		if (sep == NULL)
 			continue;
 		*sep = '\0';
 		snprintf(name, sizeof(name), "[%s]", line);
 		map = machine__new_module(machine, start, name);
 		if (map == NULL)
 			goto out_delete_line;
 		dso__kernel_module_get_build_id(map->dso, machine->root_dir);
 	}
 	free(line);
 	fclose(file);
 	return machine__set_modules_path(machine);
 out_delete_line:
 	free(line);
 out_failure:
 	return -1;
 }
 int dso__load_vmlinux(struct dso *dso, struct map *map,
 		      const char *vmlinux, symbol_filter_t filter)
 {
 	int err = -1, fd;
 	char symfs_vmlinux[PATH_MAX];
 	snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s%s",
 		 symbol_conf.symfs, vmlinux);
 	fd = open(symfs_vmlinux, O_RDONLY);
 	if (fd < 0)
 		return -1;
 	dso__set_long_name(dso, (char *)vmlinux);
 	dso__set_loaded(dso, map->type);
 	err = dso__load_sym(dso, map, symfs_vmlinux, fd, filter, 0, 0);
 	close(fd);
 	if (err > 0)
 		pr_debug("Using %s for symbols\n", symfs_vmlinux);
 	return err;
 }
 int dso__load_vmlinux_path(struct dso *dso, struct map *map,
 			   symbol_filter_t filter)
 {
 	int i, err = 0;
 	char *filename;
 	pr_debug("Looking at the vmlinux_path (%d entries long)\n",
 		 vmlinux_path__nr_entries + 1);
 	filename = dso__build_id_filename(dso, NULL, 0);
 	if (filename != NULL) {
 		err = dso__load_vmlinux(dso, map, filename, filter);
 		if (err > 0) {
 			dso__set_long_name(dso, filename);
 			goto out;
 		}
 		free(filename);
 	}
 	for (i = 0; i < vmlinux_path__nr_entries; ++i) {
 		err = dso__load_vmlinux(dso, map, vmlinux_path[i], filter);
 		if (err > 0) {
 			dso__set_long_name(dso, strdup(vmlinux_path[i]));
 			break;
 		}
 	}
 out:
 	return err;
 }
 static int dso__load_kernel_sym(struct dso *dso, struct map *map,
 				symbol_filter_t filter)
 {
 	int err;
 	const char *kallsyms_filename = NULL;
 	char *kallsyms_allocated_filename = NULL;
 	/*
 	 * Step 1: if the user specified a kallsyms or vmlinux filename, use
 	 * it and only it, reporting errors to the user if it cannot be used.
 	 *
 	 * For instance, try to analyse an ARM perf.data file _without_ a
 	 * build-id, or if the user specifies the wrong path to the right
 	 * vmlinux file, obviously we can't fallback to another vmlinux (a
 	 * x86_86 one, on the machine where analysis is being performed, say),
 	 * or worse, /proc/kallsyms.
 	 *
 	 * If the specified file _has_ a build-id and there is a build-id
 	 * section in the perf.data file, we will still do the expected
 	 * validation in dso__load_vmlinux and will bail out if they don't
 	 * match.
 	 */
 	if (symbol_conf.kallsyms_name != NULL) {
 		kallsyms_filename = symbol_conf.kallsyms_name;
 		goto do_kallsyms;
 	}
 	if (symbol_conf.vmlinux_name != NULL) {
 		err = dso__load_vmlinux(dso, map,
 					symbol_conf.vmlinux_name, filter);
 		if (err > 0) {
 			dso__set_long_name(dso,
 					   strdup(symbol_conf.vmlinux_name));
 			goto out_fixup;
 		}
 		return err;
 	}
 	if (vmlinux_path != NULL) {
 		err = dso__load_vmlinux_path(dso, map, filter);
 		if (err > 0)
 			goto out_fixup;
 	}
 	/* do not try local files if a symfs was given */
 	if (symbol_conf.symfs[0] != 0)
 		return -1;
 	/*
 	 * Say the kernel DSO was created when processing the build-id header table,
 	 * we have a build-id, so check if it is the same as the running kernel,
 	 * using it if it is.
 	 */
 	if (dso->has_build_id) {
 		u8 kallsyms_build_id[BUILD_ID_SIZE];
 		char sbuild_id[BUILD_ID_SIZE * 2 + 1];
 		if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
 					 sizeof(kallsyms_build_id)) == 0) {
 			if (dso__build_id_equal(dso, kallsyms_build_id)) {
 				kallsyms_filename = "/proc/kallsyms";
 				goto do_kallsyms;
 			}
 		}
 		/*
 		 * Now look if we have it on the build-id cache in
 		 * $HOME/.debug/[kernel.kallsyms].
 		 */
 		build_id__sprintf(dso->build_id, sizeof(dso->build_id),
 				  sbuild_id);
 		if (asprintf(&kallsyms_allocated_filename,
 			     "%s/.debug/[kernel.kallsyms]/%s",
 			     getenv("HOME"), sbuild_id) == -1) {
 			pr_err("Not enough memory for kallsyms file lookup\n");
 			return -1;
 		}
 		kallsyms_filename = kallsyms_allocated_filename;
 		if (access(kallsyms_filename, F_OK)) {
 			pr_err("No kallsyms or vmlinux with build-id %s "
 			       "was found\n", sbuild_id);
 			free(kallsyms_allocated_filename);
 			return -1;
 		}
 	} else {
 		/*
 		 * Last resort, if we don't have a build-id and couldn't find
 		 * any vmlinux file, try the running kernel kallsyms table.
 		 */
 		kallsyms_filename = "/proc/kallsyms";
 	}
 do_kallsyms:
 	err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
 	if (err > 0)
 		pr_debug("Using %s for symbols\n", kallsyms_filename);
 	free(kallsyms_allocated_filename);
 	if (err > 0) {
 out_fixup:
 		if (kallsyms_filename != NULL)
 			dso__set_long_name(dso, strdup("[kernel.kallsyms]"));
 		map__fixup_start(map);
 		map__fixup_end(map);
 	}
 	return err;
 }
 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
 				      symbol_filter_t filter)
 {
 	int err;
 	const char *kallsyms_filename = NULL;
 	struct machine *machine;
 	char path[PATH_MAX];
 	if (!map->groups) {
 		pr_debug("Guest kernel map hasn't the point to groups\n");
 		return -1;
 	}
 	machine = map->groups->machine;
 	if (machine__is_default_guest(machine)) {
 		/*
 		 * if the user specified a vmlinux filename, use it and only
 		 * it, reporting errors to the user if it cannot be used.
 		 * Or use file guest_kallsyms inputted by user on commandline
 		 */
 		if (symbol_conf.default_guest_vmlinux_name != NULL) {
 			err = dso__load_vmlinux(dso, map,
 				symbol_conf.default_guest_vmlinux_name, filter);
 			goto out_try_fixup;
 		}
 		kallsyms_filename = symbol_conf.default_guest_kallsyms;
 		if (!kallsyms_filename)
 			return -1;
 	} else {
 		sprintf(path, "%s/proc/kallsyms", machine->root_dir);
 		kallsyms_filename = path;
 	}
 	err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
 	if (err > 0)
 		pr_debug("Using %s for symbols\n", kallsyms_filename);
 out_try_fixup:
 	if (err > 0) {
 		if (kallsyms_filename != NULL) {
 			machine__mmap_name(machine, path, sizeof(path));
 			dso__set_long_name(dso, strdup(path));
 		}
 		map__fixup_start(map);
 		map__fixup_end(map);
 	}
 	return err;
 }
 static void dsos__add(struct list_head *head, struct dso *dso)
 {
 	list_add_tail(&dso->node, head);
 }
 static struct dso *dsos__find(struct list_head *head, const char *name)
 {
 	struct dso *pos;
 	list_for_each_entry(pos, head, node)
 		if (strcmp(pos->long_name, name) == 0)
 			return pos;
 	return NULL;
 }
 struct dso *__dsos__findnew(struct list_head *head, const char *name)
 {
 	struct dso *dso = dsos__find(head, name);
 	if (!dso) {
 		dso = dso__new(name);
 		if (dso != NULL) {
 			dsos__add(head, dso);
 			dso__set_basename(dso);
 		}
 	}
 	return dso;
 }
 size_t __dsos__fprintf(struct list_head *head, FILE *fp)
 {
 	struct dso *pos;
 	size_t ret = 0;
 	list_for_each_entry(pos, head, node) {
 		int i;
 		for (i = 0; i < MAP__NR_TYPES; ++i)
 			ret += dso__fprintf(pos, i, fp);
 	}
 	return ret;
 }
 size_t machines__fprintf_dsos(struct rb_root *machines, FILE *fp)
 {
 	struct rb_node *nd;
 	size_t ret = 0;
 	for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
 		struct machine *pos = rb_entry(nd, struct machine, rb_node);
 		ret += __dsos__fprintf(&pos->kernel_dsos, fp);
 		ret += __dsos__fprintf(&pos->user_dsos, fp);
 	}
 	return ret;
 }
 static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
 				      bool with_hits)
 {
 	struct dso *pos;
 	size_t ret = 0;
 	list_for_each_entry(pos, head, node) {
 		if (with_hits && !pos->hit)
 			continue;
 		ret += dso__fprintf_buildid(pos, fp);
 		ret += fprintf(fp, " %s\n", pos->long_name);
 	}
 	return ret;
 }
 size_t machine__fprintf_dsos_buildid(struct machine *machine, FILE *fp,
 				     bool with_hits)
 {
 	return __dsos__fprintf_buildid(&machine->kernel_dsos, fp, with_hits) +
 	       __dsos__fprintf_buildid(&machine->user_dsos, fp, with_hits);
 }
 size_t machines__fprintf_dsos_buildid(struct rb_root *machines,
 				      FILE *fp, bool with_hits)
 {
 	struct rb_node *nd;
 	size_t ret = 0;
 	for (nd = rb_first(machines); nd; nd = rb_next(nd)) {
 		struct machine *pos = rb_entry(nd, struct machine, rb_node);
 		ret += machine__fprintf_dsos_buildid(pos, fp, with_hits);
 	}
 	return ret;
 }
 static struct dso*
 dso__kernel_findnew(struct machine *machine, const char *name,
 		    const char *short_name, int dso_type)
 {
 	/*
 	 * The kernel dso could be created by build_id processing.
 	 */
 	struct dso *dso = __dsos__findnew(&machine->kernel_dsos, name);
 	/*
 	 * We need to run this in all cases, since during the build_id
 	 * processing we had no idea this was the kernel dso.
 	 */
 	if (dso != NULL) {
 		dso__set_short_name(dso, short_name);
 		dso->kernel = dso_type;
 	}
 	return dso;
 }
 void dso__read_running_kernel_build_id(struct dso *dso, struct machine *machine)
 {
 	char path[PATH_MAX];
 	if (machine__is_default_guest(machine))
 		return;
 	sprintf(path, "%s/sys/kernel/notes", machine->root_dir);
 	if (sysfs__read_build_id(path, dso->build_id,
 				 sizeof(dso->build_id)) == 0)
 		dso->has_build_id = true;
 }
 static struct dso *machine__get_kernel(struct machine *machine)
 {
 	const char *vmlinux_name = NULL;
 	struct dso *kernel;
 	if (machine__is_host(machine)) {
 		vmlinux_name = symbol_conf.vmlinux_name;
 		if (!vmlinux_name)
 			vmlinux_name = "[kernel.kallsyms]";
 		kernel = dso__kernel_findnew(machine, vmlinux_name,
 					     "[kernel]",
 					     DSO_TYPE_KERNEL);
 	} else {
 		char bf[PATH_MAX];
 		if (machine__is_default_guest(machine))
 			vmlinux_name = symbol_conf.default_guest_vmlinux_name;
 		if (!vmlinux_name)
 			vmlinux_name = machine__mmap_name(machine, bf,
 							  sizeof(bf));
 		kernel = dso__kernel_findnew(machine, vmlinux_name,
 					     "[guest.kernel]",
 					     DSO_TYPE_GUEST_KERNEL);
 	}
 	if (kernel != NULL && (!kernel->has_build_id))
 		dso__read_running_kernel_build_id(kernel, machine);
 	return kernel;
 }
 struct process_args {
 	u64 start;
 };
 static int symbol__in_kernel(void *arg, const char *name,
 			     char type __used, u64 start, u64 end __used)
 {
 	struct process_args *args = arg;
 	if (strchr(name, '['))
 		return 0;
 	args->start = start;
 	return 1;
 }
 /* Figure out the start address of kernel map from /proc/kallsyms */
 static u64 machine__get_kernel_start_addr(struct machine *machine)
 {
 	const char *filename;
 	char path[PATH_MAX];
 	struct process_args args;
 	if (machine__is_host(machine)) {
 		filename = "/proc/kallsyms";
 	} else {
 		if (machine__is_default_guest(machine))
 			filename = (char *)symbol_conf.default_guest_kallsyms;
 		else {
 			sprintf(path, "%s/proc/kallsyms", machine->root_dir);
 			filename = path;
 		}
 	}
 	if (symbol__restricted_filename(filename, "/proc/kallsyms"))
 		return 0;
 	if (kallsyms__parse(filename, &args, symbol__in_kernel) <= 0)
 		return 0;
 	return args.start;
 }
 int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel)
 {
 	enum map_type type;
 	u64 start = machine__get_kernel_start_addr(machine);
 	for (type = 0; type < MAP__NR_TYPES; ++type) {
 		struct kmap *kmap;
 		machine->vmlinux_maps[type] = map__new2(start, kernel, type);
 		if (machine->vmlinux_maps[type] == NULL)
 			return -1;
 		machine->vmlinux_maps[type]->map_ip =
 			machine->vmlinux_maps[type]->unmap_ip =
 				identity__map_ip;
 		kmap = map__kmap(machine->vmlinux_maps[type]);
 		kmap->kmaps = &machine->kmaps;
 		map_groups__insert(&machine->kmaps,
 				   machine->vmlinux_maps[type]);
 	}
 	return 0;
 }
 void machine__destroy_kernel_maps(struct machine *machine)
 {
 	enum map_type type;
 	for (type = 0; type < MAP__NR_TYPES; ++type) {
 		struct kmap *kmap;
 		if (machine->vmlinux_maps[type] == NULL)
 			continue;
 		kmap = map__kmap(machine->vmlinux_maps[type]);
 		map_groups__remove(&machine->kmaps,
 				   machine->vmlinux_maps[type]);
 		if (kmap->ref_reloc_sym) {
 			/*
 			 * ref_reloc_sym is shared among all maps, so free just
 			 * on one of them.
 			 */
 			if (type == MAP__FUNCTION) {
 				free((char *)kmap->ref_reloc_sym->name);
 				kmap->ref_reloc_sym->name = NULL;
 				free(kmap->ref_reloc_sym);
 			}
 			kmap->ref_reloc_sym = NULL;
 		}
 		map__delete(machine->vmlinux_maps[type]);
 		machine->vmlinux_maps[type] = NULL;
 	}
 }
 int machine__create_kernel_maps(struct machine *machine)
 {
 	struct dso *kernel = machine__get_kernel(machine);
 	if (kernel == NULL ||
 	    __machine__create_kernel_maps(machine, kernel) < 0)
 		return -1;
 	if (symbol_conf.use_modules && machine__create_modules(machine) < 0)
 		pr_debug("Problems creating module maps, continuing anyway...\n");
 	/*
 	 * Now that we have all the maps created, just set the ->end of them:
 	 */
 	map_groups__fixup_end(&machine->kmaps);
 	return 0;
 }
 static void vmlinux_path__exit(void)
 {
 	while (--vmlinux_path__nr_entries >= 0) {
 		free(vmlinux_path[vmlinux_path__nr_entries]);
 		vmlinux_path[vmlinux_path__nr_entries] = NULL;
 	}
 	free(vmlinux_path);
 	vmlinux_path = NULL;
 }
 static int vmlinux_path__init(void)
 {
 	struct utsname uts;
 	char bf[PATH_MAX];
 	vmlinux_path = malloc(sizeof(char *) * 5);
 	if (vmlinux_path == NULL)
 		return -1;
 	vmlinux_path[vmlinux_path__nr_entries] = strdup("vmlinux");
 	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
 		goto out_fail;
 	++vmlinux_path__nr_entries;
 	vmlinux_path[vmlinux_path__nr_entries] = strdup("/boot/vmlinux");
 	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
 		goto out_fail;
 	++vmlinux_path__nr_entries;
 	/* only try running kernel version if no symfs was given */
 	if (symbol_conf.symfs[0] != 0)
 		return 0;
 	if (uname(&uts) < 0)
 		return -1;
 	snprintf(bf, sizeof(bf), "/boot/vmlinux-%s", uts.release);
 	vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
 	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
 		goto out_fail;
 	++vmlinux_path__nr_entries;
 	snprintf(bf, sizeof(bf), "/lib/modules/%s/build/vmlinux", uts.release);
 	vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
 	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
 		goto out_fail;
 	++vmlinux_path__nr_entries;
 	snprintf(bf, sizeof(bf), "/usr/lib/debug/lib/modules/%s/vmlinux",
 		 uts.release);
 	vmlinux_path[vmlinux_path__nr_entries] = strdup(bf);
 	if (vmlinux_path[vmlinux_path__nr_entries] == NULL)
 		goto out_fail;
 	++vmlinux_path__nr_entries;
 	return 0;
 out_fail:
 	vmlinux_path__exit();
 	return -1;
 }
 size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp)
 {
 	int i;
 	size_t printed = 0;
 	struct dso *kdso = machine->vmlinux_maps[MAP__FUNCTION]->dso;
 	if (kdso->has_build_id) {
 		char filename[PATH_MAX];
 		if (dso__build_id_filename(kdso, filename, sizeof(filename)))
 			printed += fprintf(fp, "[0] %s\n", filename);
 	}
 	for (i = 0; i < vmlinux_path__nr_entries; ++i)
 		printed += fprintf(fp, "[%d] %s\n",
 				   i + kdso->has_build_id, vmlinux_path[i]);
 	return printed;
 }
 static int setup_list(struct strlist **list, const char *list_str,
 		      const char *list_name)
 {
 	if (list_str == NULL)
 		return 0;
 	*list = strlist__new(true, list_str);
 	if (!*list) {
 		pr_err("problems parsing %s list\n", list_name);
 		return -1;
 	}
 	return 0;
 }
 static bool symbol__read_kptr_restrict(void)
 {
 	bool value = false;
 	if (geteuid() != 0) {
 		FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
 		if (fp != NULL) {
 			char line[8];
 			if (fgets(line, sizeof(line), fp) != NULL)
 				value = atoi(line) != 0;
 			fclose(fp);
 		}
 	}
 	return value;
 }
 int symbol__init(void)
 {
 	const char *symfs;
 	if (symbol_conf.initialized)
 		return 0;
 	symbol_conf.priv_size = ALIGN(symbol_conf.priv_size, sizeof(u64));
 	elf_version(EV_CURRENT);
 	if (symbol_conf.sort_by_name)
 		symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
 					  sizeof(struct symbol));
 	if (symbol_conf.try_vmlinux_path && vmlinux_path__init() < 0)
 		return -1;
 	if (symbol_conf.field_sep && *symbol_conf.field_sep == '.') {
 		pr_err("'.' is the only non valid --field-separator argument\n");
 		return -1;
 	}
 	if (setup_list(&symbol_conf.dso_list,
 		       symbol_conf.dso_list_str, "dso") < 0)
 		return -1;
 	if (setup_list(&symbol_conf.comm_list,
 		       symbol_conf.comm_list_str, "comm") < 0)
 		goto out_free_dso_list;
 	if (setup_list(&symbol_conf.sym_list,
 		       symbol_conf.sym_list_str, "symbol") < 0)
 		goto out_free_comm_list;
 	/*
 	 * A path to symbols of "/" is identical to ""
 	 * reset here for simplicity.
 	 */
 	symfs = realpath(symbol_conf.symfs, NULL);
 	if (symfs == NULL)
 		symfs = symbol_conf.symfs;
 	if (strcmp(symfs, "/") == 0)
 		symbol_conf.symfs = "";
 	if (symfs != symbol_conf.symfs)
 		free((void *)symfs);
 	symbol_conf.kptr_restrict = symbol__read_kptr_restrict();
 	symbol_conf.initialized = true;
 	return 0;
 out_free_comm_list:
 	strlist__delete(symbol_conf.comm_list);
 out_free_dso_list:
 	strlist__delete(symbol_conf.dso_list);
 	return -1;
 }
 void symbol__exit(void)
 {
 	if (!symbol_conf.initialized)
 		return;
 	strlist__delete(symbol_conf.sym_list);
 	strlist__delete(symbol_conf.dso_list);
 	strlist__delete(symbol_conf.comm_list);
 	vmlinux_path__exit();
 	symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
 	symbol_conf.initialized = false;
 }
 int machines__create_kernel_maps(struct rb_root *machines, pid_t pid)
 {
 	struct machine *machine = machines__findnew(machines, pid);
 	if (machine == NULL)
 		return -1;
 	return machine__create_kernel_maps(machine);
 }
 static int hex(char ch)
 {
 	if ((ch >= '0') && (ch <= '9'))
 		return ch - '0';
 	if ((ch >= 'a') && (ch <= 'f'))
 		return ch - 'a' + 10;
 	if ((ch >= 'A') && (ch <= 'F'))
 		return ch - 'A' + 10;
 	return -1;
 }
 /*
  * While we find nice hex chars, build a long_val.
  * Return number of chars processed.
  */
 int hex2u64(const char *ptr, u64 *long_val)
 {
 	const char *p = ptr;
 	*long_val = 0;
 	while (*p) {
 		const int hex_val = hex(*p);
 		if (hex_val < 0)
 			break;
 		*long_val = (*long_val << 4) | hex_val;
 		p++;
 	}
 	return p - ptr;
 }
 char *strxfrchar(char *s, char from, char to)
 {
 	char *p = s;
 	while ((p = strchr(p, from)) != NULL)
 		*p++ = to;
 	return s;
 }
 int machines__create_guest_kernel_maps(struct rb_root *machines)
 {
 	int ret = 0;
 	struct dirent **namelist = NULL;
 	int i, items = 0;
 	char path[PATH_MAX];
 	pid_t pid;
 	if (symbol_conf.default_guest_vmlinux_name ||
 	    symbol_conf.default_guest_modules ||
 	    symbol_conf.default_guest_kallsyms) {
 		machines__create_kernel_maps(machines, DEFAULT_GUEST_KERNEL_ID);
 	}
 	if (symbol_conf.guestmount) {
 		items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
 		if (items <= 0)
 			return -ENOENT;
 		for (i = 0; i < items; i++) {
 			if (!isdigit(namelist[i]->d_name[0])) {
 				/* Filter out . and .. */
 				continue;
 			}
 			pid = atoi(namelist[i]->d_name);
 			sprintf(path, "%s/%s/proc/kallsyms",
 				symbol_conf.guestmount,
 				namelist[i]->d_name);
 			ret = access(path, R_OK);
 			if (ret) {
 				pr_debug("Can't access file %s\n", path);
 				goto failure;
 			}
 			machines__create_kernel_maps(machines, pid);
 		}
 failure:
 		free(namelist);
 	}
 	return ret;
 }
 void machines__destroy_guest_kernel_maps(struct rb_root *machines)
 {
 	struct rb_node *next = rb_first(machines);
 	while (next) {
 		struct machine *pos = rb_entry(next, struct machine, rb_node);
 		next = rb_next(&pos->rb_node);
 		rb_erase(&pos->rb_node, machines);
 		machine__delete(pos);
 	}
 }
 int machine__load_kallsyms(struct machine *machine, const char *filename,
 			   enum map_type type, symbol_filter_t filter)
 {
 	struct map *map = machine->vmlinux_maps[type];
 	int ret = dso__load_kallsyms(map->dso, filename, map, filter);
 	if (ret > 0) {
 		dso__set_loaded(map->dso, type);
 		/*
 		 * Since /proc/kallsyms will have multiple sessions for the
 		 * kernel, with modules between them, fixup the end of all
 		 * sections.
 		 */
 		__map_groups__fixup_end(&machine->kmaps, type);
 	}
 	return ret;
 }
 int machine__load_vmlinux_path(struct machine *machine, enum map_type type,
 			       symbol_filter_t filter)
 {
 	struct map *map = machine->vmlinux_maps[type];
 	int ret = dso__load_vmlinux_path(map->dso, map, filter);
 	if (ret > 0) {
 		dso__set_loaded(map->dso, type);
 		map__reloc_vmlinux(map);
 	}
 	return ret;
 }

tools/perf/util/trace-event-parse.c

Diff comments View file @ 0a84f00

1	/*	1	/*
2	* Copyright (C) 2009, Steven Rostedt <srostedt@redhat.com>	2	* Copyright (C) 2009, Steven Rostedt <srostedt@redhat.com>
3	*	3	*
4	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~	4	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5	*	5	*
6	* This program is free software; you can redistribute it and/or modify	6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by	7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; version 2 of the License (not later!)	8	* the Free Software Foundation; version 2 of the License (not later!)
9	*	9	*
10	* This program is distributed in the hope that it will be useful,	10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.	13	* GNU General Public License for more details.
14	*	14	*
15	* You should have received a copy of the GNU General Public License	15	* You should have received a copy of the GNU General Public License
16	* along with this program; if not, write to the Free Software	16	* along with this program; if not, write to the Free Software
17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18	*	18	*
19	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~	19	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
20	*	20	*
21	* The parts for function graph printing was taken and modified from the	21	* The parts for function graph printing was taken and modified from the
22	* Linux Kernel that were written by Frederic Weisbecker.	22	* Linux Kernel that were written by Frederic Weisbecker.
23	*/	23	*/
24	#define _GNU_SOURCE	24
25	#include <stdio.h>	25	#include <stdio.h>
26	#include <stdlib.h>	26	#include <stdlib.h>
27	#include <string.h>	27	#include <string.h>
28	#include <ctype.h>	28	#include <ctype.h>
29	#include <errno.h>	29	#include <errno.h>
30		30
31	#undef _GNU_SOURCE
32	#include "../perf.h"	31	#include "../perf.h"
33	#include "util.h"	32	#include "util.h"
34	#include "trace-event.h"	33	#include "trace-event.h"
35		34
36	int header_page_ts_offset;	35	int header_page_ts_offset;
37	int header_page_ts_size;	36	int header_page_ts_size;
38	int header_page_size_offset;	37	int header_page_size_offset;
39	int header_page_size_size;	38	int header_page_size_size;
40	int header_page_overwrite_offset;	39	int header_page_overwrite_offset;
41	int header_page_overwrite_size;	40	int header_page_overwrite_size;
42	int header_page_data_offset;	41	int header_page_data_offset;
43	int header_page_data_size;	42	int header_page_data_size;
44		43
45	bool latency_format;	44	bool latency_format;
46		45
47	static char *input_buf;	46	static char *input_buf;
48	static unsigned long long input_buf_ptr;	47	static unsigned long long input_buf_ptr;
49	static unsigned long long input_buf_siz;	48	static unsigned long long input_buf_siz;
50		49
51	static int cpus;	50	static int cpus;
52	static int long_size;	51	static int long_size;
53	static int is_flag_field;	52	static int is_flag_field;
54	static int is_symbolic_field;	53	static int is_symbolic_field;
55		54
56	static struct format_field *	55	static struct format_field *
57	find_any_field(struct event event, const char name);	56	find_any_field(struct event event, const char name);
58		57
59	static void init_input_buf(char *buf, unsigned long long size)	58	static void init_input_buf(char *buf, unsigned long long size)
60	{	59	{
61	input_buf = buf;	60	input_buf = buf;
62	input_buf_siz = size;	61	input_buf_siz = size;
63	input_buf_ptr = 0;	62	input_buf_ptr = 0;
64	}	63	}
65		64
66	struct cmdline {	65	struct cmdline {
67	char *comm;	66	char *comm;
68	int pid;	67	int pid;
69	};	68	};
70		69
71	static struct cmdline *cmdlines;	70	static struct cmdline *cmdlines;
72	static int cmdline_count;	71	static int cmdline_count;
73		72
74	static int cmdline_cmp(const void a, const void b)	73	static int cmdline_cmp(const void a, const void b)
75	{	74	{
76	const struct cmdline *ca = a;	75	const struct cmdline *ca = a;
77	const struct cmdline *cb = b;	76	const struct cmdline *cb = b;
78		77
79	if (ca->pid < cb->pid)	78	if (ca->pid < cb->pid)
80	return -1;	79	return -1;
81	if (ca->pid > cb->pid)	80	if (ca->pid > cb->pid)
82	return 1;	81	return 1;
83		82
84	return 0;	83	return 0;
85	}	84	}
86		85
87	void parse_cmdlines(char *file, int size __unused)	86	void parse_cmdlines(char *file, int size __unused)
88	{	87	{
89	struct cmdline_list {	88	struct cmdline_list {
90	struct cmdline_list *next;	89	struct cmdline_list *next;
91	char *comm;	90	char *comm;
92	int pid;	91	int pid;
93	} list = NULL, item;	92	} list = NULL, item;
94	char *line;	93	char *line;
95	char *next = NULL;	94	char *next = NULL;
96	int i;	95	int i;
97		96
98	line = strtok_r(file, "\n", &next);	97	line = strtok_r(file, "\n", &next);
99	while (line) {	98	while (line) {
100	item = malloc_or_die(sizeof(*item));	99	item = malloc_or_die(sizeof(*item));
101	sscanf(line, "%d %as", &item->pid,	100	sscanf(line, "%d %as", &item->pid,
102	(float )(void )&item->comm); /* workaround gcc warning */	101	(float )(void )&item->comm); /* workaround gcc warning */
103	item->next = list;	102	item->next = list;
104	list = item;	103	list = item;
105	line = strtok_r(NULL, "\n", &next);	104	line = strtok_r(NULL, "\n", &next);
106	cmdline_count++;	105	cmdline_count++;
107	}	106	}
108		107
109	cmdlines = malloc_or_die(sizeof(cmdlines) cmdline_count);	108	cmdlines = malloc_or_die(sizeof(cmdlines) cmdline_count);
110		109
111	i = 0;	110	i = 0;
112	while (list) {	111	while (list) {
113	cmdlines[i].pid = list->pid;	112	cmdlines[i].pid = list->pid;
114	cmdlines[i].comm = list->comm;	113	cmdlines[i].comm = list->comm;
115	i++;	114	i++;
116	item = list;	115	item = list;
117	list = list->next;	116	list = list->next;
118	free(item);	117	free(item);
119	}	118	}
120		119
121	qsort(cmdlines, cmdline_count, sizeof(*cmdlines), cmdline_cmp);	120	qsort(cmdlines, cmdline_count, sizeof(*cmdlines), cmdline_cmp);
122	}	121	}
123		122
124	static struct func_map {	123	static struct func_map {
125	unsigned long long addr;	124	unsigned long long addr;
126	char *func;	125	char *func;
127	char *mod;	126	char *mod;
128	} *func_list;	127	} *func_list;
129	static unsigned int func_count;	128	static unsigned int func_count;
130		129
131	static int func_cmp(const void a, const void b)	130	static int func_cmp(const void a, const void b)
132	{	131	{
133	const struct func_map *fa = a;	132	const struct func_map *fa = a;
134	const struct func_map *fb = b;	133	const struct func_map *fb = b;
135		134
136	if (fa->addr < fb->addr)	135	if (fa->addr < fb->addr)
137	return -1;	136	return -1;
138	if (fa->addr > fb->addr)	137	if (fa->addr > fb->addr)
139	return 1;	138	return 1;
140		139
141	return 0;	140	return 0;
142	}	141	}
143		142
144	void parse_proc_kallsyms(char *file, unsigned int size __unused)	143	void parse_proc_kallsyms(char *file, unsigned int size __unused)
145	{	144	{
146	struct func_list {	145	struct func_list {
147	struct func_list *next;	146	struct func_list *next;
148	unsigned long long addr;	147	unsigned long long addr;
149	char *func;	148	char *func;
150	char *mod;	149	char *mod;
151	} list = NULL, item;	150	} list = NULL, item;
152	char *line;	151	char *line;
153	char *next = NULL;	152	char *next = NULL;
154	char *addr_str;	153	char *addr_str;
155	char ch;	154	char ch;
156	int ret __used;	155	int ret __used;
157	int i;	156	int i;
158		157
159	line = strtok_r(file, "\n", &next);	158	line = strtok_r(file, "\n", &next);
160	while (line) {	159	while (line) {
161	item = malloc_or_die(sizeof(*item));	160	item = malloc_or_die(sizeof(*item));
162	item->mod = NULL;	161	item->mod = NULL;
163	ret = sscanf(line, "%as %c %as\t[%as",	162	ret = sscanf(line, "%as %c %as\t[%as",
164	(float )(void )&addr_str, /* workaround gcc warning */	163	(float )(void )&addr_str, /* workaround gcc warning */
165	&ch,	164	&ch,
166	(float )(void )&item->func,	165	(float )(void )&item->func,
167	(float )(void )&item->mod);	166	(float )(void )&item->mod);
168	item->addr = strtoull(addr_str, NULL, 16);	167	item->addr = strtoull(addr_str, NULL, 16);
169	free(addr_str);	168	free(addr_str);
170		169
171	/* truncate the extra ']' */	170	/* truncate the extra ']' */
172	if (item->mod)	171	if (item->mod)
173	item->mod[strlen(item->mod) - 1] = 0;	172	item->mod[strlen(item->mod) - 1] = 0;
174		173
175		174
176	item->next = list;	175	item->next = list;
177	list = item;	176	list = item;
178	line = strtok_r(NULL, "\n", &next);	177	line = strtok_r(NULL, "\n", &next);
179	func_count++;	178	func_count++;
180	}	179	}
181		180
182	func_list = malloc_or_die(sizeof(func_list) (func_count + 1));	181	func_list = malloc_or_die(sizeof(func_list) (func_count + 1));
183		182
184	i = 0;	183	i = 0;
185	while (list) {	184	while (list) {
186	func_list[i].func = list->func;	185	func_list[i].func = list->func;
187	func_list[i].addr = list->addr;	186	func_list[i].addr = list->addr;
188	func_list[i].mod = list->mod;	187	func_list[i].mod = list->mod;
189	i++;	188	i++;
190	item = list;	189	item = list;
191	list = list->next;	190	list = list->next;
192	free(item);	191	free(item);
193	}	192	}
194		193
195	qsort(func_list, func_count, sizeof(*func_list), func_cmp);	194	qsort(func_list, func_count, sizeof(*func_list), func_cmp);
196		195
197	/*	196	/*
198	* Add a special record at the end.	197	* Add a special record at the end.
199	*/	198	*/
200	func_list[func_count].func = NULL;	199	func_list[func_count].func = NULL;
201	func_list[func_count].addr = 0;	200	func_list[func_count].addr = 0;
202	func_list[func_count].mod = NULL;	201	func_list[func_count].mod = NULL;
203	}	202	}
204		203
205	/*	204	/*
206	* We are searching for a record in between, not an exact	205	* We are searching for a record in between, not an exact
207	* match.	206	* match.
208	*/	207	*/
209	static int func_bcmp(const void a, const void b)	208	static int func_bcmp(const void a, const void b)
210	{	209	{
211	const struct func_map *fa = a;	210	const struct func_map *fa = a;
212	const struct func_map *fb = b;	211	const struct func_map *fb = b;
213		212
214	if ((fa->addr == fb->addr) \|\|	213	if ((fa->addr == fb->addr) \|\|
215		214
216	(fa->addr > fb->addr &&	215	(fa->addr > fb->addr &&
217	fa->addr < (fb+1)->addr))	216	fa->addr < (fb+1)->addr))
218	return 0;	217	return 0;
219		218
220	if (fa->addr < fb->addr)	219	if (fa->addr < fb->addr)
221	return -1;	220	return -1;
222		221
223	return 1;	222	return 1;
224	}	223	}
225		224
226	static struct func_map *find_func(unsigned long long addr)	225	static struct func_map *find_func(unsigned long long addr)
227	{	226	{
228	struct func_map *func;	227	struct func_map *func;
229	struct func_map key;	228	struct func_map key;
230		229
231	key.addr = addr;	230	key.addr = addr;
232		231
233	func = bsearch(&key, func_list, func_count, sizeof(*func_list),	232	func = bsearch(&key, func_list, func_count, sizeof(*func_list),
234	func_bcmp);	233	func_bcmp);
235		234
236	return func;	235	return func;
237	}	236	}
238		237
239	void print_funcs(void)	238	void print_funcs(void)
240	{	239	{
241	int i;	240	int i;
242		241
243	for (i = 0; i < (int)func_count; i++) {	242	for (i = 0; i < (int)func_count; i++) {
244	printf("%016llx %s",	243	printf("%016llx %s",
245	func_list[i].addr,	244	func_list[i].addr,
246	func_list[i].func);	245	func_list[i].func);
247	if (func_list[i].mod)	246	if (func_list[i].mod)
248	printf(" [%s]\n", func_list[i].mod);	247	printf(" [%s]\n", func_list[i].mod);
249	else	248	else
250	printf("\n");	249	printf("\n");
251	}	250	}
252	}	251	}
253		252
254	static struct printk_map {	253	static struct printk_map {
255	unsigned long long addr;	254	unsigned long long addr;
256	char *printk;	255	char *printk;
257	} *printk_list;	256	} *printk_list;
258	static unsigned int printk_count;	257	static unsigned int printk_count;
259		258
260	static int printk_cmp(const void a, const void b)	259	static int printk_cmp(const void a, const void b)
261	{	260	{
262	const struct func_map *fa = a;	261	const struct func_map *fa = a;
263	const struct func_map *fb = b;	262	const struct func_map *fb = b;
264		263
265	if (fa->addr < fb->addr)	264	if (fa->addr < fb->addr)
266	return -1;	265	return -1;
267	if (fa->addr > fb->addr)	266	if (fa->addr > fb->addr)
268	return 1;	267	return 1;
269		268
270	return 0;	269	return 0;
271	}	270	}
272		271
273	static struct printk_map *find_printk(unsigned long long addr)	272	static struct printk_map *find_printk(unsigned long long addr)
274	{	273	{
275	struct printk_map *printk;	274	struct printk_map *printk;
276	struct printk_map key;	275	struct printk_map key;
277		276
278	key.addr = addr;	277	key.addr = addr;
279		278
280	printk = bsearch(&key, printk_list, printk_count, sizeof(*printk_list),	279	printk = bsearch(&key, printk_list, printk_count, sizeof(*printk_list),
281	printk_cmp);	280	printk_cmp);
282		281
283	return printk;	282	return printk;
284	}	283	}
285		284
286	void parse_ftrace_printk(char *file, unsigned int size __unused)	285	void parse_ftrace_printk(char *file, unsigned int size __unused)
287	{	286	{
288	struct printk_list {	287	struct printk_list {
289	struct printk_list *next;	288	struct printk_list *next;
290	unsigned long long addr;	289	unsigned long long addr;
291	char *printk;	290	char *printk;
292	} list = NULL, item;	291	} list = NULL, item;
293	char *line;	292	char *line;
294	char *next = NULL;	293	char *next = NULL;
295	char *addr_str;	294	char *addr_str;
296	int i;	295	int i;
297		296
298	line = strtok_r(file, "\n", &next);	297	line = strtok_r(file, "\n", &next);
299	while (line) {	298	while (line) {
300	addr_str = strsep(&line, ":");	299	addr_str = strsep(&line, ":");
301	if (!line) {	300	if (!line) {
302	warning("error parsing print strings");	301	warning("error parsing print strings");
303	break;	302	break;
304	}	303	}
305	item = malloc_or_die(sizeof(*item));	304	item = malloc_or_die(sizeof(*item));
306	item->addr = strtoull(addr_str, NULL, 16);	305	item->addr = strtoull(addr_str, NULL, 16);
307	/* fmt still has a space, skip it */	306	/* fmt still has a space, skip it */
308	item->printk = strdup(line+1);	307	item->printk = strdup(line+1);
309	item->next = list;	308	item->next = list;
310	list = item;	309	list = item;
311	line = strtok_r(NULL, "\n", &next);	310	line = strtok_r(NULL, "\n", &next);
312	printk_count++;	311	printk_count++;
313	}	312	}
314		313
315	printk_list = malloc_or_die(sizeof(printk_list) printk_count + 1);	314	printk_list = malloc_or_die(sizeof(printk_list) printk_count + 1);
316		315
317	i = 0;	316	i = 0;
318	while (list) {	317	while (list) {
319	printk_list[i].printk = list->printk;	318	printk_list[i].printk = list->printk;
320	printk_list[i].addr = list->addr;	319	printk_list[i].addr = list->addr;
321	i++;	320	i++;
322	item = list;	321	item = list;
323	list = list->next;	322	list = list->next;
324	free(item);	323	free(item);
325	}	324	}
326		325
327	qsort(printk_list, printk_count, sizeof(*printk_list), printk_cmp);	326	qsort(printk_list, printk_count, sizeof(*printk_list), printk_cmp);
328	}	327	}
329		328
330	void print_printk(void)	329	void print_printk(void)
331	{	330	{
332	int i;	331	int i;
333		332
334	for (i = 0; i < (int)printk_count; i++) {	333	for (i = 0; i < (int)printk_count; i++) {
335	printf("%016llx %s\n",	334	printf("%016llx %s\n",
336	printk_list[i].addr,	335	printk_list[i].addr,
337	printk_list[i].printk);	336	printk_list[i].printk);
338	}	337	}
339	}	338	}
340		339
341	static struct event *alloc_event(void)	340	static struct event *alloc_event(void)
342	{	341	{
343	struct event *event;	342	struct event *event;
344		343
345	event = malloc_or_die(sizeof(*event));	344	event = malloc_or_die(sizeof(*event));
346	memset(event, 0, sizeof(*event));	345	memset(event, 0, sizeof(*event));
347		346
348	return event;	347	return event;
349	}	348	}
350		349
351	enum event_type {	350	enum event_type {
352	EVENT_ERROR,	351	EVENT_ERROR,
353	EVENT_NONE,	352	EVENT_NONE,
354	EVENT_SPACE,	353	EVENT_SPACE,
355	EVENT_NEWLINE,	354	EVENT_NEWLINE,
356	EVENT_OP,	355	EVENT_OP,
357	EVENT_DELIM,	356	EVENT_DELIM,
358	EVENT_ITEM,	357	EVENT_ITEM,
359	EVENT_DQUOTE,	358	EVENT_DQUOTE,
360	EVENT_SQUOTE,	359	EVENT_SQUOTE,
361	};	360	};
362		361
363	static struct event *event_list;	362	static struct event *event_list;
364		363
365	static void add_event(struct event *event)	364	static void add_event(struct event *event)
366	{	365	{
367	event->next = event_list;	366	event->next = event_list;
368	event_list = event;	367	event_list = event;
369	}	368	}
370		369
371	static int event_item_type(enum event_type type)	370	static int event_item_type(enum event_type type)
372	{	371	{
373	switch (type) {	372	switch (type) {
374	case EVENT_ITEM ... EVENT_SQUOTE:	373	case EVENT_ITEM ... EVENT_SQUOTE:
375	return 1;	374	return 1;
376	case EVENT_ERROR ... EVENT_DELIM:	375	case EVENT_ERROR ... EVENT_DELIM:
377	default:	376	default:
378	return 0;	377	return 0;
379	}	378	}
380	}	379	}
381		380
382	static void free_arg(struct print_arg *arg)	381	static void free_arg(struct print_arg *arg)
383	{	382	{
384	if (!arg)	383	if (!arg)
385	return;	384	return;
386		385
387	switch (arg->type) {	386	switch (arg->type) {
388	case PRINT_ATOM:	387	case PRINT_ATOM:
389	if (arg->atom.atom)	388	if (arg->atom.atom)
390	free(arg->atom.atom);	389	free(arg->atom.atom);
391	break;	390	break;
392	case PRINT_NULL:	391	case PRINT_NULL:
393	case PRINT_FIELD ... PRINT_OP:	392	case PRINT_FIELD ... PRINT_OP:
394	default:	393	default:
395	/* todo */	394	/* todo */
396	break;	395	break;
397	}	396	}
398		397
399	free(arg);	398	free(arg);
400	}	399	}
401		400
402	static enum event_type get_type(int ch)	401	static enum event_type get_type(int ch)
403	{	402	{
404	if (ch == '\n')	403	if (ch == '\n')
405	return EVENT_NEWLINE;	404	return EVENT_NEWLINE;
406	if (isspace(ch))	405	if (isspace(ch))
407	return EVENT_SPACE;	406	return EVENT_SPACE;
408	if (isalnum(ch) \|\| ch == '_')	407	if (isalnum(ch) \|\| ch == '_')
409	return EVENT_ITEM;	408	return EVENT_ITEM;
410	if (ch == '\'')	409	if (ch == '\'')
411	return EVENT_SQUOTE;	410	return EVENT_SQUOTE;
412	if (ch == '"')	411	if (ch == '"')
413	return EVENT_DQUOTE;	412	return EVENT_DQUOTE;
414	if (!isprint(ch))	413	if (!isprint(ch))
415	return EVENT_NONE;	414	return EVENT_NONE;
416	if (ch == '(' \|\| ch == ')' \|\| ch == ',')	415	if (ch == '(' \|\| ch == ')' \|\| ch == ',')
417	return EVENT_DELIM;	416	return EVENT_DELIM;
418		417
419	return EVENT_OP;	418	return EVENT_OP;
420	}	419	}
421		420
422	static int __read_char(void)	421	static int __read_char(void)
423	{	422	{
424	if (input_buf_ptr >= input_buf_siz)	423	if (input_buf_ptr >= input_buf_siz)
425	return -1;	424	return -1;
426		425
427	return input_buf[input_buf_ptr++];	426	return input_buf[input_buf_ptr++];
428	}	427	}
429		428
430	static int __peek_char(void)	429	static int __peek_char(void)
431	{	430	{
432	if (input_buf_ptr >= input_buf_siz)	431	if (input_buf_ptr >= input_buf_siz)
433	return -1;	432	return -1;
434		433
435	return input_buf[input_buf_ptr];	434	return input_buf[input_buf_ptr];
436	}	435	}
437		436
438	static enum event_type __read_token(char **tok)	437	static enum event_type __read_token(char **tok)
439	{	438	{
440	char buf[BUFSIZ];	439	char buf[BUFSIZ];
441	int ch, last_ch, quote_ch, next_ch;	440	int ch, last_ch, quote_ch, next_ch;
442	int i = 0;	441	int i = 0;
443	int tok_size = 0;	442	int tok_size = 0;
444	enum event_type type;	443	enum event_type type;
445		444
446	*tok = NULL;	445	*tok = NULL;
447		446
448		447
449	ch = __read_char();	448	ch = __read_char();
450	if (ch < 0)	449	if (ch < 0)
451	return EVENT_NONE;	450	return EVENT_NONE;
452		451
453	type = get_type(ch);	452	type = get_type(ch);
454	if (type == EVENT_NONE)	453	if (type == EVENT_NONE)
455	return type;	454	return type;
456		455
457	buf[i++] = ch;	456	buf[i++] = ch;
458		457
459	switch (type) {	458	switch (type) {
460	case EVENT_NEWLINE:	459	case EVENT_NEWLINE:
461	case EVENT_DELIM:	460	case EVENT_DELIM:
462	*tok = malloc_or_die(2);	461	*tok = malloc_or_die(2);
463	(*tok)[0] = ch;	462	(*tok)[0] = ch;
464	(*tok)[1] = 0;	463	(*tok)[1] = 0;
465	return type;	464	return type;
466		465
467	case EVENT_OP:	466	case EVENT_OP:
468	switch (ch) {	467	switch (ch) {
469	case '-':	468	case '-':
470	next_ch = __peek_char();	469	next_ch = __peek_char();
471	if (next_ch == '>') {	470	if (next_ch == '>') {
472	buf[i++] = __read_char();	471	buf[i++] = __read_char();
473	break;	472	break;
474	}	473	}
475	/* fall through */	474	/* fall through */
476	case '+':	475	case '+':
477	case '\|':	476	case '\|':
478	case '&':	477	case '&':
479	case '>':	478	case '>':
480	case '<':	479	case '<':
481	last_ch = ch;	480	last_ch = ch;
482	ch = __peek_char();	481	ch = __peek_char();
483	if (ch != last_ch)	482	if (ch != last_ch)
484	goto test_equal;	483	goto test_equal;
485	buf[i++] = __read_char();	484	buf[i++] = __read_char();
486	switch (last_ch) {	485	switch (last_ch) {
487	case '>':	486	case '>':
488	case '<':	487	case '<':
489	goto test_equal;	488	goto test_equal;
490	default:	489	default:
491	break;	490	break;
492	}	491	}
493	break;	492	break;
494	case '!':	493	case '!':
495	case '=':	494	case '=':
496	goto test_equal;	495	goto test_equal;
497	default: /* what should we do instead? */	496	default: /* what should we do instead? */
498	break;	497	break;
499	}	498	}
500	buf[i] = 0;	499	buf[i] = 0;
501	*tok = strdup(buf);	500	*tok = strdup(buf);
502	return type;	501	return type;
503		502
504	test_equal:	503	test_equal:
505	ch = __peek_char();	504	ch = __peek_char();
506	if (ch == '=')	505	if (ch == '=')
507	buf[i++] = __read_char();	506	buf[i++] = __read_char();
508	break;	507	break;
509		508
510	case EVENT_DQUOTE:	509	case EVENT_DQUOTE:
511	case EVENT_SQUOTE:	510	case EVENT_SQUOTE:
512	/* don't keep quotes */	511	/* don't keep quotes */
513	i--;	512	i--;
514	quote_ch = ch;	513	quote_ch = ch;
515	last_ch = 0;	514	last_ch = 0;
516	do {	515	do {
517	if (i == (BUFSIZ - 1)) {	516	if (i == (BUFSIZ - 1)) {
518	buf[i] = 0;	517	buf[i] = 0;
519	if (*tok) {	518	if (*tok) {
520	tok = realloc(tok, tok_size + BUFSIZ);	519	tok = realloc(tok, tok_size + BUFSIZ);
521	if (!*tok)	520	if (!*tok)
522	return EVENT_NONE;	521	return EVENT_NONE;
523	strcat(*tok, buf);	522	strcat(*tok, buf);
524	} else	523	} else
525	*tok = strdup(buf);	524	*tok = strdup(buf);
526		525
527	if (!*tok)	526	if (!*tok)
528	return EVENT_NONE;	527	return EVENT_NONE;
529	tok_size += BUFSIZ;	528	tok_size += BUFSIZ;
530	i = 0;	529	i = 0;
531	}	530	}
532	last_ch = ch;	531	last_ch = ch;
533	ch = __read_char();	532	ch = __read_char();
534	buf[i++] = ch;	533	buf[i++] = ch;
535	/* the '\' '\' will cancel itself */	534	/* the '\' '\' will cancel itself */
536	if (ch == '\\' && last_ch == '\\')	535	if (ch == '\\' && last_ch == '\\')
537	last_ch = 0;	536	last_ch = 0;
538	} while (ch != quote_ch \|\| last_ch == '\\');	537	} while (ch != quote_ch \|\| last_ch == '\\');
539	/* remove the last quote */	538	/* remove the last quote */
540	i--;	539	i--;
541	goto out;	540	goto out;
542		541
543	case EVENT_ERROR ... EVENT_SPACE:	542	case EVENT_ERROR ... EVENT_SPACE:
544	case EVENT_ITEM:	543	case EVENT_ITEM:
545	default:	544	default:
546	break;	545	break;
547	}	546	}
548		547
549	while (get_type(__peek_char()) == type) {	548	while (get_type(__peek_char()) == type) {
550	if (i == (BUFSIZ - 1)) {	549	if (i == (BUFSIZ - 1)) {
551	buf[i] = 0;	550	buf[i] = 0;
552	if (*tok) {	551	if (*tok) {
553	tok = realloc(tok, tok_size + BUFSIZ);	552	tok = realloc(tok, tok_size + BUFSIZ);
554	if (!*tok)	553	if (!*tok)
555	return EVENT_NONE;	554	return EVENT_NONE;
556	strcat(*tok, buf);	555	strcat(*tok, buf);
557	} else	556	} else
558	*tok = strdup(buf);	557	*tok = strdup(buf);
559		558
560	if (!*tok)	559	if (!*tok)
561	return EVENT_NONE;	560	return EVENT_NONE;
562	tok_size += BUFSIZ;	561	tok_size += BUFSIZ;
563	i = 0;	562	i = 0;
564	}	563	}
565	ch = __read_char();	564	ch = __read_char();
566	buf[i++] = ch;	565	buf[i++] = ch;
567	}	566	}
568		567
569	out:	568	out:
570	buf[i] = 0;	569	buf[i] = 0;
571	if (*tok) {	570	if (*tok) {
572	tok = realloc(tok, tok_size + i);	571	tok = realloc(tok, tok_size + i);
573	if (!*tok)	572	if (!*tok)
574	return EVENT_NONE;	573	return EVENT_NONE;
575	strcat(*tok, buf);	574	strcat(*tok, buf);
576	} else	575	} else
577	*tok = strdup(buf);	576	*tok = strdup(buf);
578	if (!*tok)	577	if (!*tok)
579	return EVENT_NONE;	578	return EVENT_NONE;
580		579
581	return type;	580	return type;
582	}	581	}
583		582
584	static void free_token(char *tok)	583	static void free_token(char *tok)
585	{	584	{
586	if (tok)	585	if (tok)
587	free(tok);	586	free(tok);
588	}	587	}
589		588
590	static enum event_type read_token(char **tok)	589	static enum event_type read_token(char **tok)
591	{	590	{
592	enum event_type type;	591	enum event_type type;
593		592
594	for (;;) {	593	for (;;) {
595	type = __read_token(tok);	594	type = __read_token(tok);
596	if (type != EVENT_SPACE)	595	if (type != EVENT_SPACE)
597	return type;	596	return type;
598		597
599	free_token(*tok);	598	free_token(*tok);
600	}	599	}
601		600
602	/* not reached */	601	/* not reached */
603	return EVENT_NONE;	602	return EVENT_NONE;
604	}	603	}
605		604
606	/* no newline */	605	/* no newline */
607	static enum event_type read_token_item(char **tok)	606	static enum event_type read_token_item(char **tok)
608	{	607	{
609	enum event_type type;	608	enum event_type type;
610		609
611	for (;;) {	610	for (;;) {
612	type = __read_token(tok);	611	type = __read_token(tok);
613	if (type != EVENT_SPACE && type != EVENT_NEWLINE)	612	if (type != EVENT_SPACE && type != EVENT_NEWLINE)
614	return type;	613	return type;
615		614
616	free_token(*tok);	615	free_token(*tok);
617	}	616	}
618		617
619	/* not reached */	618	/* not reached */
620	return EVENT_NONE;	619	return EVENT_NONE;
621	}	620	}
622		621
623	static int test_type(enum event_type type, enum event_type expect)	622	static int test_type(enum event_type type, enum event_type expect)
624	{	623	{
625	if (type != expect) {	624	if (type != expect) {
626	warning("Error: expected type %d but read %d",	625	warning("Error: expected type %d but read %d",
627	expect, type);	626	expect, type);
628	return -1;	627	return -1;
629	}	628	}
630	return 0;	629	return 0;
631	}	630	}
632		631
633	static int __test_type_token(enum event_type type, char *token,	632	static int __test_type_token(enum event_type type, char *token,
634	enum event_type expect, const char *expect_tok,	633	enum event_type expect, const char *expect_tok,
635	bool warn)	634	bool warn)
636	{	635	{
637	if (type != expect) {	636	if (type != expect) {
638	if (warn)	637	if (warn)
639	warning("Error: expected type %d but read %d",	638	warning("Error: expected type %d but read %d",
640	expect, type);	639	expect, type);
641	return -1;	640	return -1;
642	}	641	}
643		642
644	if (strcmp(token, expect_tok) != 0) {	643	if (strcmp(token, expect_tok) != 0) {
645	if (warn)	644	if (warn)
646	warning("Error: expected '%s' but read '%s'",	645	warning("Error: expected '%s' but read '%s'",
647	expect_tok, token);	646	expect_tok, token);
648	return -1;	647	return -1;
649	}	648	}
650	return 0;	649	return 0;
651	}	650	}
652		651
653	static int test_type_token(enum event_type type, char *token,	652	static int test_type_token(enum event_type type, char *token,
654	enum event_type expect, const char *expect_tok)	653	enum event_type expect, const char *expect_tok)
655	{	654	{
656	return __test_type_token(type, token, expect, expect_tok, true);	655	return __test_type_token(type, token, expect, expect_tok, true);
657	}	656	}
658		657
659	static int __read_expect_type(enum event_type expect, char **tok, int newline_ok)	658	static int __read_expect_type(enum event_type expect, char **tok, int newline_ok)
660	{	659	{
661	enum event_type type;	660	enum event_type type;
662		661
663	if (newline_ok)	662	if (newline_ok)
664	type = read_token(tok);	663	type = read_token(tok);
665	else	664	else
666	type = read_token_item(tok);	665	type = read_token_item(tok);
667	return test_type(type, expect);	666	return test_type(type, expect);
668	}	667	}
669		668
670	static int read_expect_type(enum event_type expect, char **tok)	669	static int read_expect_type(enum event_type expect, char **tok)
671	{	670	{
672	return __read_expect_type(expect, tok, 1);	671	return __read_expect_type(expect, tok, 1);
673	}	672	}
674		673
675	static int __read_expected(enum event_type expect, const char *str,	674	static int __read_expected(enum event_type expect, const char *str,
676	int newline_ok, bool warn)	675	int newline_ok, bool warn)
677	{	676	{
678	enum event_type type;	677	enum event_type type;
679	char *token;	678	char *token;
680	int ret;	679	int ret;
681		680
682	if (newline_ok)	681	if (newline_ok)
683	type = read_token(&token);	682	type = read_token(&token);
684	else	683	else
685	type = read_token_item(&token);	684	type = read_token_item(&token);
686		685
687	ret = __test_type_token(type, token, expect, str, warn);	686	ret = __test_type_token(type, token, expect, str, warn);
688		687
689	free_token(token);	688	free_token(token);
690		689
691	return ret;	690	return ret;
692	}	691	}
693		692
694	static int read_expected(enum event_type expect, const char *str)	693	static int read_expected(enum event_type expect, const char *str)
695	{	694	{
696	return __read_expected(expect, str, 1, true);	695	return __read_expected(expect, str, 1, true);
697	}	696	}
698		697
699	static int read_expected_item(enum event_type expect, const char *str)	698	static int read_expected_item(enum event_type expect, const char *str)
700	{	699	{
701	return __read_expected(expect, str, 0, true);	700	return __read_expected(expect, str, 0, true);
702	}	701	}
703		702
704	static char *event_read_name(void)	703	static char *event_read_name(void)
705	{	704	{
706	char *token;	705	char *token;
707		706
708	if (read_expected(EVENT_ITEM, "name") < 0)	707	if (read_expected(EVENT_ITEM, "name") < 0)
709	return NULL;	708	return NULL;
710		709
711	if (read_expected(EVENT_OP, ":") < 0)	710	if (read_expected(EVENT_OP, ":") < 0)
712	return NULL;	711	return NULL;
713		712
714	if (read_expect_type(EVENT_ITEM, &token) < 0)	713	if (read_expect_type(EVENT_ITEM, &token) < 0)
715	goto fail;	714	goto fail;
716		715
717	return token;	716	return token;
718		717
719	fail:	718	fail:
720	free_token(token);	719	free_token(token);
721	return NULL;	720	return NULL;
722	}	721	}
723		722
724	static int event_read_id(void)	723	static int event_read_id(void)
725	{	724	{
726	char *token;	725	char *token;
727	int id;	726	int id;
728		727
729	if (read_expected_item(EVENT_ITEM, "ID") < 0)	728	if (read_expected_item(EVENT_ITEM, "ID") < 0)
730	return -1;	729	return -1;
731		730
732	if (read_expected(EVENT_OP, ":") < 0)	731	if (read_expected(EVENT_OP, ":") < 0)
733	return -1;	732	return -1;
734		733
735	if (read_expect_type(EVENT_ITEM, &token) < 0)	734	if (read_expect_type(EVENT_ITEM, &token) < 0)
736	goto fail;	735	goto fail;
737		736
738	id = strtoul(token, NULL, 0);	737	id = strtoul(token, NULL, 0);
739	free_token(token);	738	free_token(token);
740	return id;	739	return id;
741		740
742	fail:	741	fail:
743	free_token(token);	742	free_token(token);
744	return -1;	743	return -1;
745	}	744	}
746		745
747	static int field_is_string(struct format_field *field)	746	static int field_is_string(struct format_field *field)
748	{	747	{
749	if ((field->flags & FIELD_IS_ARRAY) &&	748	if ((field->flags & FIELD_IS_ARRAY) &&
750	(!strstr(field->type, "char") \|\| !strstr(field->type, "u8") \|\|	749	(!strstr(field->type, "char") \|\| !strstr(field->type, "u8") \|\|
751	!strstr(field->type, "s8")))	750	!strstr(field->type, "s8")))
752	return 1;	751	return 1;
753		752
754	return 0;	753	return 0;
755	}	754	}
756		755
757	static int field_is_dynamic(struct format_field *field)	756	static int field_is_dynamic(struct format_field *field)
758	{	757	{
759	if (!strncmp(field->type, "__data_loc", 10))	758	if (!strncmp(field->type, "__data_loc", 10))
760	return 1;	759	return 1;
761		760
762	return 0;	761	return 0;
763	}	762	}
764		763
765	static int event_read_fields(struct event event, struct format_field *fields)	764	static int event_read_fields(struct event event, struct format_field *fields)
766	{	765	{
767	struct format_field *field = NULL;	766	struct format_field *field = NULL;
768	enum event_type type;	767	enum event_type type;
769	char *token;	768	char *token;
770	char *last_token;	769	char *last_token;
771	int count = 0;	770	int count = 0;
772		771
773	do {	772	do {
774	type = read_token(&token);	773	type = read_token(&token);
775	if (type == EVENT_NEWLINE) {	774	if (type == EVENT_NEWLINE) {
776	free_token(token);	775	free_token(token);
777	return count;	776	return count;
778	}	777	}
779		778
780	count++;	779	count++;
781		780
782	if (test_type_token(type, token, EVENT_ITEM, "field"))	781	if (test_type_token(type, token, EVENT_ITEM, "field"))
783	goto fail;	782	goto fail;
784	free_token(token);	783	free_token(token);
785		784
786	type = read_token(&token);	785	type = read_token(&token);
787	/*	786	/*
788	* The ftrace fields may still use the "special" name.	787	* The ftrace fields may still use the "special" name.
789	* Just ignore it.	788	* Just ignore it.
790	*/	789	*/
791	if (event->flags & EVENT_FL_ISFTRACE &&	790	if (event->flags & EVENT_FL_ISFTRACE &&
792	type == EVENT_ITEM && strcmp(token, "special") == 0) {	791	type == EVENT_ITEM && strcmp(token, "special") == 0) {
793	free_token(token);	792	free_token(token);
794	type = read_token(&token);	793	type = read_token(&token);
795	}	794	}
796		795
797	if (test_type_token(type, token, EVENT_OP, ":") < 0)	796	if (test_type_token(type, token, EVENT_OP, ":") < 0)
798	return -1;	797	return -1;
799		798
800	if (read_expect_type(EVENT_ITEM, &token) < 0)	799	if (read_expect_type(EVENT_ITEM, &token) < 0)
801	goto fail;	800	goto fail;
802		801
803	last_token = token;	802	last_token = token;
804		803
805	field = malloc_or_die(sizeof(*field));	804	field = malloc_or_die(sizeof(*field));
806	memset(field, 0, sizeof(*field));	805	memset(field, 0, sizeof(*field));
807		806
808	/* read the rest of the type */	807	/* read the rest of the type */
809	for (;;) {	808	for (;;) {
810	type = read_token(&token);	809	type = read_token(&token);
811	if (type == EVENT_ITEM \|\|	810	if (type == EVENT_ITEM \|\|
812	(type == EVENT_OP && strcmp(token, "*") == 0) \|\|	811	(type == EVENT_OP && strcmp(token, "*") == 0) \|\|
813	/*	812	/*
814	* Some of the ftrace fields are broken and have	813	* Some of the ftrace fields are broken and have
815	* an illegal "." in them.	814	* an illegal "." in them.
816	*/	815	*/
817	(event->flags & EVENT_FL_ISFTRACE &&	816	(event->flags & EVENT_FL_ISFTRACE &&
818	type == EVENT_OP && strcmp(token, ".") == 0)) {	817	type == EVENT_OP && strcmp(token, ".") == 0)) {
819		818
820	if (strcmp(token, "*") == 0)	819	if (strcmp(token, "*") == 0)
821	field->flags \|= FIELD_IS_POINTER;	820	field->flags \|= FIELD_IS_POINTER;
822		821
823	if (field->type) {	822	if (field->type) {
824	field->type = realloc(field->type,	823	field->type = realloc(field->type,
825	strlen(field->type) +	824	strlen(field->type) +
826	strlen(last_token) + 2);	825	strlen(last_token) + 2);
827	strcat(field->type, " ");	826	strcat(field->type, " ");
828	strcat(field->type, last_token);	827	strcat(field->type, last_token);
829	} else	828	} else
830	field->type = last_token;	829	field->type = last_token;
831	last_token = token;	830	last_token = token;
832	continue;	831	continue;
833	}	832	}
834		833
835	break;	834	break;
836	}	835	}
837		836
838	if (!field->type) {	837	if (!field->type) {
839	die("no type found");	838	die("no type found");
840	goto fail;	839	goto fail;
841	}	840	}
842	field->name = last_token;	841	field->name = last_token;
843		842
844	if (test_type(type, EVENT_OP))	843	if (test_type(type, EVENT_OP))
845	goto fail;	844	goto fail;
846		845
847	if (strcmp(token, "[") == 0) {	846	if (strcmp(token, "[") == 0) {
848	enum event_type last_type = type;	847	enum event_type last_type = type;
849	char *brackets = token;	848	char *brackets = token;
850	int len;	849	int len;
851		850
852	field->flags \|= FIELD_IS_ARRAY;	851	field->flags \|= FIELD_IS_ARRAY;
853		852
854	type = read_token(&token);	853	type = read_token(&token);
855	while (strcmp(token, "]") != 0) {	854	while (strcmp(token, "]") != 0) {
856	if (last_type == EVENT_ITEM &&	855	if (last_type == EVENT_ITEM &&
857	type == EVENT_ITEM)	856	type == EVENT_ITEM)
858	len = 2;	857	len = 2;
859	else	858	else
860	len = 1;	859	len = 1;
861	last_type = type;	860	last_type = type;
862		861
863	brackets = realloc(brackets,	862	brackets = realloc(brackets,
864	strlen(brackets) +	863	strlen(brackets) +
865	strlen(token) + len);	864	strlen(token) + len);
866	if (len == 2)	865	if (len == 2)
867	strcat(brackets, " ");	866	strcat(brackets, " ");
868	strcat(brackets, token);	867	strcat(brackets, token);
869	free_token(token);	868	free_token(token);
870	type = read_token(&token);	869	type = read_token(&token);
871	if (type == EVENT_NONE) {	870	if (type == EVENT_NONE) {
872	die("failed to find token");	871	die("failed to find token");
873	goto fail;	872	goto fail;
874	}	873	}
875	}	874	}
876		875
877	free_token(token);	876	free_token(token);
878		877
879	brackets = realloc(brackets, strlen(brackets) + 2);	878	brackets = realloc(brackets, strlen(brackets) + 2);
880	strcat(brackets, "]");	879	strcat(brackets, "]");
881		880
882	/* add brackets to type */	881	/* add brackets to type */
883		882
884	type = read_token(&token);	883	type = read_token(&token);
885	/*	884	/*
886	* If the next token is not an OP, then it is of	885	* If the next token is not an OP, then it is of
887	* the format: type [] item;	886	* the format: type [] item;
888	*/	887	*/
889	if (type == EVENT_ITEM) {	888	if (type == EVENT_ITEM) {
890	field->type = realloc(field->type,	889	field->type = realloc(field->type,
891	strlen(field->type) +	890	strlen(field->type) +
892	strlen(field->name) +	891	strlen(field->name) +
893	strlen(brackets) + 2);	892	strlen(brackets) + 2);
894	strcat(field->type, " ");	893	strcat(field->type, " ");
895	strcat(field->type, field->name);	894	strcat(field->type, field->name);
896	free_token(field->name);	895	free_token(field->name);
897	strcat(field->type, brackets);	896	strcat(field->type, brackets);
898	field->name = token;	897	field->name = token;
899	type = read_token(&token);	898	type = read_token(&token);
900	} else {	899	} else {
901	field->type = realloc(field->type,	900	field->type = realloc(field->type,
902	strlen(field->type) +	901	strlen(field->type) +
903	strlen(brackets) + 1);	902	strlen(brackets) + 1);
904	strcat(field->type, brackets);	903	strcat(field->type, brackets);
905	}	904	}
906	free(brackets);	905	free(brackets);
907	}	906	}
908		907
909	if (field_is_string(field)) {	908	if (field_is_string(field)) {
910	field->flags \|= FIELD_IS_STRING;	909	field->flags \|= FIELD_IS_STRING;
911	if (field_is_dynamic(field))	910	if (field_is_dynamic(field))
912	field->flags \|= FIELD_IS_DYNAMIC;	911	field->flags \|= FIELD_IS_DYNAMIC;
913	}	912	}
914		913
915	if (test_type_token(type, token, EVENT_OP, ";"))	914	if (test_type_token(type, token, EVENT_OP, ";"))
916	goto fail;	915	goto fail;
917	free_token(token);	916	free_token(token);
918		917
919	if (read_expected(EVENT_ITEM, "offset") < 0)	918	if (read_expected(EVENT_ITEM, "offset") < 0)
920	goto fail_expect;	919	goto fail_expect;
921		920
922	if (read_expected(EVENT_OP, ":") < 0)	921	if (read_expected(EVENT_OP, ":") < 0)
923	goto fail_expect;	922	goto fail_expect;
924		923
925	if (read_expect_type(EVENT_ITEM, &token))	924	if (read_expect_type(EVENT_ITEM, &token))
926	goto fail;	925	goto fail;
927	field->offset = strtoul(token, NULL, 0);	926	field->offset = strtoul(token, NULL, 0);
928	free_token(token);	927	free_token(token);
929		928
930	if (read_expected(EVENT_OP, ";") < 0)	929	if (read_expected(EVENT_OP, ";") < 0)
931	goto fail_expect;	930	goto fail_expect;
932		931
933	if (read_expected(EVENT_ITEM, "size") < 0)	932	if (read_expected(EVENT_ITEM, "size") < 0)
934	goto fail_expect;	933	goto fail_expect;
935		934
936	if (read_expected(EVENT_OP, ":") < 0)	935	if (read_expected(EVENT_OP, ":") < 0)
937	goto fail_expect;	936	goto fail_expect;
938		937
939	if (read_expect_type(EVENT_ITEM, &token))	938	if (read_expect_type(EVENT_ITEM, &token))
940	goto fail;	939	goto fail;
941	field->size = strtoul(token, NULL, 0);	940	field->size = strtoul(token, NULL, 0);
942	free_token(token);	941	free_token(token);
943		942
944	if (read_expected(EVENT_OP, ";") < 0)	943	if (read_expected(EVENT_OP, ";") < 0)
945	goto fail_expect;	944	goto fail_expect;
946		945
947	type = read_token(&token);	946	type = read_token(&token);
948	if (type != EVENT_NEWLINE) {	947	if (type != EVENT_NEWLINE) {
949	/* newer versions of the kernel have a "signed" type */	948	/* newer versions of the kernel have a "signed" type */
950	if (test_type_token(type, token, EVENT_ITEM, "signed"))	949	if (test_type_token(type, token, EVENT_ITEM, "signed"))
951	goto fail;	950	goto fail;
952		951
953	free_token(token);	952	free_token(token);
954		953
955	if (read_expected(EVENT_OP, ":") < 0)	954	if (read_expected(EVENT_OP, ":") < 0)
956	goto fail_expect;	955	goto fail_expect;
957		956
958	if (read_expect_type(EVENT_ITEM, &token))	957	if (read_expect_type(EVENT_ITEM, &token))
959	goto fail;	958	goto fail;
960		959
961	if (strtoul(token, NULL, 0))	960	if (strtoul(token, NULL, 0))
962	field->flags \|= FIELD_IS_SIGNED;	961	field->flags \|= FIELD_IS_SIGNED;
963		962
964	free_token(token);	963	free_token(token);
965	if (read_expected(EVENT_OP, ";") < 0)	964	if (read_expected(EVENT_OP, ";") < 0)
966	goto fail_expect;	965	goto fail_expect;
967		966
968	if (read_expect_type(EVENT_NEWLINE, &token))	967	if (read_expect_type(EVENT_NEWLINE, &token))
969	goto fail;	968	goto fail;
970	}	969	}
971		970
972	free_token(token);	971	free_token(token);
973		972
974	*fields = field;	973	*fields = field;
975	fields = &field->next;	974	fields = &field->next;
976		975
977	} while (1);	976	} while (1);
978		977
979	return 0;	978	return 0;
980		979
981	fail:	980	fail:
982	free_token(token);	981	free_token(token);
983	fail_expect:	982	fail_expect:
984	if (field)	983	if (field)
985	free(field);	984	free(field);
986	return -1;	985	return -1;
987	}	986	}
988		987
989	static int event_read_format(struct event *event)	988	static int event_read_format(struct event *event)
990	{	989	{
991	char *token;	990	char *token;
992	int ret;	991	int ret;
993		992
994	if (read_expected_item(EVENT_ITEM, "format") < 0)	993	if (read_expected_item(EVENT_ITEM, "format") < 0)
995	return -1;	994	return -1;
996		995
997	if (read_expected(EVENT_OP, ":") < 0)	996	if (read_expected(EVENT_OP, ":") < 0)
998	return -1;	997	return -1;
999		998
1000	if (read_expect_type(EVENT_NEWLINE, &token))	999	if (read_expect_type(EVENT_NEWLINE, &token))
1001	goto fail;	1000	goto fail;
1002	free_token(token);	1001	free_token(token);
1003		1002
1004	ret = event_read_fields(event, &event->format.common_fields);	1003	ret = event_read_fields(event, &event->format.common_fields);
1005	if (ret < 0)	1004	if (ret < 0)
1006	return ret;	1005	return ret;
1007	event->format.nr_common = ret;	1006	event->format.nr_common = ret;
1008		1007
1009	ret = event_read_fields(event, &event->format.fields);	1008	ret = event_read_fields(event, &event->format.fields);
1010	if (ret < 0)	1009	if (ret < 0)
1011	return ret;	1010	return ret;
1012	event->format.nr_fields = ret;	1011	event->format.nr_fields = ret;
1013		1012
1014	return 0;	1013	return 0;
1015		1014
1016	fail:	1015	fail:
1017	free_token(token);	1016	free_token(token);
1018	return -1;	1017	return -1;
1019	}	1018	}
1020		1019
1021	enum event_type	1020	enum event_type
1022	process_arg_token(struct event event, struct print_arg arg,	1021	process_arg_token(struct event event, struct print_arg arg,
1023	char **tok, enum event_type type);	1022	char **tok, enum event_type type);
1024		1023
1025	static enum event_type	1024	static enum event_type
1026	process_arg(struct event event, struct print_arg arg, char **tok)	1025	process_arg(struct event event, struct print_arg arg, char **tok)
1027	{	1026	{
1028	enum event_type type;	1027	enum event_type type;
1029	char *token;	1028	char *token;
1030		1029
1031	type = read_token(&token);	1030	type = read_token(&token);
1032	*tok = token;	1031	*tok = token;
1033		1032
1034	return process_arg_token(event, arg, tok, type);	1033	return process_arg_token(event, arg, tok, type);
1035	}	1034	}
1036		1035
1037	static enum event_type	1036	static enum event_type
1038	process_cond(struct event event, struct print_arg top, char **tok)	1037	process_cond(struct event event, struct print_arg top, char **tok)
1039	{	1038	{
1040	struct print_arg arg, left, *right;	1039	struct print_arg arg, left, *right;
1041	enum event_type type;	1040	enum event_type type;
1042	char *token = NULL;	1041	char *token = NULL;
1043		1042
1044	arg = malloc_or_die(sizeof(*arg));	1043	arg = malloc_or_die(sizeof(*arg));
1045	memset(arg, 0, sizeof(*arg));	1044	memset(arg, 0, sizeof(*arg));
1046		1045
1047	left = malloc_or_die(sizeof(*left));	1046	left = malloc_or_die(sizeof(*left));
1048		1047
1049	right = malloc_or_die(sizeof(*right));	1048	right = malloc_or_die(sizeof(*right));
1050		1049
1051	arg->type = PRINT_OP;	1050	arg->type = PRINT_OP;
1052	arg->op.left = left;	1051	arg->op.left = left;
1053	arg->op.right = right;	1052	arg->op.right = right;
1054		1053
1055	*tok = NULL;	1054	*tok = NULL;
1056	type = process_arg(event, left, &token);	1055	type = process_arg(event, left, &token);
1057	if (test_type_token(type, token, EVENT_OP, ":"))	1056	if (test_type_token(type, token, EVENT_OP, ":"))
1058	goto out_free;	1057	goto out_free;
1059		1058
1060	arg->op.op = token;	1059	arg->op.op = token;
1061		1060
1062	type = process_arg(event, right, &token);	1061	type = process_arg(event, right, &token);
1063		1062
1064	top->op.right = arg;	1063	top->op.right = arg;
1065		1064
1066	*tok = token;	1065	*tok = token;
1067	return type;	1066	return type;
1068		1067
1069	out_free:	1068	out_free:
1070	free_token(*tok);	1069	free_token(*tok);
1071	free(right);	1070	free(right);
1072	free(left);	1071	free(left);
1073	free_arg(arg);	1072	free_arg(arg);
1074	return EVENT_ERROR;	1073	return EVENT_ERROR;
1075	}	1074	}
1076		1075
1077	static enum event_type	1076	static enum event_type
1078	process_array(struct event event, struct print_arg top, char **tok)	1077	process_array(struct event event, struct print_arg top, char **tok)
1079	{	1078	{
1080	struct print_arg *arg;	1079	struct print_arg *arg;
1081	enum event_type type;	1080	enum event_type type;
1082	char *token = NULL;	1081	char *token = NULL;
1083		1082
1084	arg = malloc_or_die(sizeof(*arg));	1083	arg = malloc_or_die(sizeof(*arg));
1085	memset(arg, 0, sizeof(*arg));	1084	memset(arg, 0, sizeof(*arg));
1086		1085
1087	*tok = NULL;	1086	*tok = NULL;
1088	type = process_arg(event, arg, &token);	1087	type = process_arg(event, arg, &token);
1089	if (test_type_token(type, token, EVENT_OP, "]"))	1088	if (test_type_token(type, token, EVENT_OP, "]"))
1090	goto out_free;	1089	goto out_free;
1091		1090
1092	top->op.right = arg;	1091	top->op.right = arg;
1093		1092
1094	free_token(token);	1093	free_token(token);
1095	type = read_token_item(&token);	1094	type = read_token_item(&token);
1096	*tok = token;	1095	*tok = token;
1097		1096
1098	return type;	1097	return type;
1099		1098
1100	out_free:	1099	out_free:
1101	free_token(*tok);	1100	free_token(*tok);
1102	free_arg(arg);	1101	free_arg(arg);
1103	return EVENT_ERROR;	1102	return EVENT_ERROR;
1104	}	1103	}
1105		1104
1106	static int get_op_prio(char *op)	1105	static int get_op_prio(char *op)
1107	{	1106	{
1108	if (!op[1]) {	1107	if (!op[1]) {
1109	switch (op[0]) {	1108	switch (op[0]) {
1110	case '*':	1109	case '*':
1111	case '/':	1110	case '/':
1112	case '%':	1111	case '%':
1113	return 6;	1112	return 6;
1114	case '+':	1113	case '+':
1115	case '-':	1114	case '-':
1116	return 7;	1115	return 7;
1117	/* '>>' and '<<' are 8 */	1116	/* '>>' and '<<' are 8 */
1118	case '<':	1117	case '<':
1119	case '>':	1118	case '>':
1120	return 9;	1119	return 9;
1121	/* '==' and '!=' are 10 */	1120	/* '==' and '!=' are 10 */
1122	case '&':	1121	case '&':
1123	return 11;	1122	return 11;
1124	case '^':	1123	case '^':
1125	return 12;	1124	return 12;
1126	case '\|':	1125	case '\|':
1127	return 13;	1126	return 13;
1128	case '?':	1127	case '?':
1129	return 16;	1128	return 16;
1130	default:	1129	default:
1131	die("unknown op '%c'", op[0]);	1130	die("unknown op '%c'", op[0]);
1132	return -1;	1131	return -1;
1133	}	1132	}
1134	} else {	1133	} else {
1135	if (strcmp(op, "++") == 0 \|\|	1134	if (strcmp(op, "++") == 0 \|\|
1136	strcmp(op, "--") == 0) {	1135	strcmp(op, "--") == 0) {
1137	return 3;	1136	return 3;
1138	} else if (strcmp(op, ">>") == 0 \|\|	1137	} else if (strcmp(op, ">>") == 0 \|\|
1139	strcmp(op, "<<") == 0) {	1138	strcmp(op, "<<") == 0) {
1140	return 8;	1139	return 8;
1141	} else if (strcmp(op, ">=") == 0 \|\|	1140	} else if (strcmp(op, ">=") == 0 \|\|
1142	strcmp(op, "<=") == 0) {	1141	strcmp(op, "<=") == 0) {
1143	return 9;	1142	return 9;
1144	} else if (strcmp(op, "==") == 0 \|\|	1143	} else if (strcmp(op, "==") == 0 \|\|
1145	strcmp(op, "!=") == 0) {	1144	strcmp(op, "!=") == 0) {
1146	return 10;	1145	return 10;
1147	} else if (strcmp(op, "&&") == 0) {	1146	} else if (strcmp(op, "&&") == 0) {
1148	return 14;	1147	return 14;
1149	} else if (strcmp(op, "\|\|") == 0) {	1148	} else if (strcmp(op, "\|\|") == 0) {
1150	return 15;	1149	return 15;
1151	} else {	1150	} else {
1152	die("unknown op '%s'", op);	1151	die("unknown op '%s'", op);
1153	return -1;	1152	return -1;
1154	}	1153	}
1155	}	1154	}
1156	}	1155	}
1157		1156
1158	static void set_op_prio(struct print_arg *arg)	1157	static void set_op_prio(struct print_arg *arg)
1159	{	1158	{
1160		1159
1161	/* single ops are the greatest */	1160	/* single ops are the greatest */
1162	if (!arg->op.left \|\| arg->op.left->type == PRINT_NULL) {	1161	if (!arg->op.left \|\| arg->op.left->type == PRINT_NULL) {
1163	arg->op.prio = 0;	1162	arg->op.prio = 0;
1164	return;	1163	return;
1165	}	1164	}
1166		1165
1167	arg->op.prio = get_op_prio(arg->op.op);	1166	arg->op.prio = get_op_prio(arg->op.op);
1168	}	1167	}
1169		1168
1170	static enum event_type	1169	static enum event_type
1171	process_op(struct event event, struct print_arg arg, char **tok)	1170	process_op(struct event event, struct print_arg arg, char **tok)
1172	{	1171	{
1173	struct print_arg left, right = NULL;	1172	struct print_arg left, right = NULL;
1174	enum event_type type;	1173	enum event_type type;
1175	char *token;	1174	char *token;
1176		1175
1177	/* the op is passed in via tok */	1176	/* the op is passed in via tok */
1178	token = *tok;	1177	token = *tok;
1179		1178
1180	if (arg->type == PRINT_OP && !arg->op.left) {	1179	if (arg->type == PRINT_OP && !arg->op.left) {
1181	/* handle single op */	1180	/* handle single op */
1182	if (token[1]) {	1181	if (token[1]) {
1183	die("bad op token %s", token);	1182	die("bad op token %s", token);
1184	return EVENT_ERROR;	1183	return EVENT_ERROR;
1185	}	1184	}
1186	switch (token[0]) {	1185	switch (token[0]) {
1187	case '!':	1186	case '!':
1188	case '+':	1187	case '+':
1189	case '-':	1188	case '-':
1190	break;	1189	break;
1191	default:	1190	default:
1192	die("bad op token %s", token);	1191	die("bad op token %s", token);
1193	return EVENT_ERROR;	1192	return EVENT_ERROR;
1194	}	1193	}
1195		1194
1196	/* make an empty left */	1195	/* make an empty left */
1197	left = malloc_or_die(sizeof(*left));	1196	left = malloc_or_die(sizeof(*left));
1198	left->type = PRINT_NULL;	1197	left->type = PRINT_NULL;
1199	arg->op.left = left;	1198	arg->op.left = left;
1200		1199
1201	right = malloc_or_die(sizeof(*right));	1200	right = malloc_or_die(sizeof(*right));
1202	arg->op.right = right;	1201	arg->op.right = right;
1203		1202
1204	type = process_arg(event, right, tok);	1203	type = process_arg(event, right, tok);
1205		1204
1206	} else if (strcmp(token, "?") == 0) {	1205	} else if (strcmp(token, "?") == 0) {
1207		1206
1208	left = malloc_or_die(sizeof(*left));	1207	left = malloc_or_die(sizeof(*left));
1209	/* copy the top arg to the left */	1208	/* copy the top arg to the left */
1210	left = arg;	1209	left = arg;
1211		1210
1212	arg->type = PRINT_OP;	1211	arg->type = PRINT_OP;
1213	arg->op.op = token;	1212	arg->op.op = token;
1214	arg->op.left = left;	1213	arg->op.left = left;
1215	arg->op.prio = 0;	1214	arg->op.prio = 0;
1216		1215
1217	type = process_cond(event, arg, tok);	1216	type = process_cond(event, arg, tok);
1218		1217
1219	} else if (strcmp(token, ">>") == 0 \|\|	1218	} else if (strcmp(token, ">>") == 0 \|\|
1220	strcmp(token, "<<") == 0 \|\|	1219	strcmp(token, "<<") == 0 \|\|
1221	strcmp(token, "&") == 0 \|\|	1220	strcmp(token, "&") == 0 \|\|
1222	strcmp(token, "\|") == 0 \|\|	1221	strcmp(token, "\|") == 0 \|\|
1223	strcmp(token, "&&") == 0 \|\|	1222	strcmp(token, "&&") == 0 \|\|
1224	strcmp(token, "\|\|") == 0 \|\|	1223	strcmp(token, "\|\|") == 0 \|\|
1225	strcmp(token, "-") == 0 \|\|	1224	strcmp(token, "-") == 0 \|\|
1226	strcmp(token, "+") == 0 \|\|	1225	strcmp(token, "+") == 0 \|\|
1227	strcmp(token, "*") == 0 \|\|	1226	strcmp(token, "*") == 0 \|\|
1228	strcmp(token, "^") == 0 \|\|	1227	strcmp(token, "^") == 0 \|\|
1229	strcmp(token, "/") == 0 \|\|	1228	strcmp(token, "/") == 0 \|\|
1230	strcmp(token, "<") == 0 \|\|	1229	strcmp(token, "<") == 0 \|\|
1231	strcmp(token, ">") == 0 \|\|	1230	strcmp(token, ">") == 0 \|\|
1232	strcmp(token, "==") == 0 \|\|	1231	strcmp(token, "==") == 0 \|\|
1233	strcmp(token, "!=") == 0) {	1232	strcmp(token, "!=") == 0) {
1234		1233
1235	left = malloc_or_die(sizeof(*left));	1234	left = malloc_or_die(sizeof(*left));
1236		1235
1237	/* copy the top arg to the left */	1236	/* copy the top arg to the left */
1238	left = arg;	1237	left = arg;
1239		1238
1240	arg->type = PRINT_OP;	1239	arg->type = PRINT_OP;
1241	arg->op.op = token;	1240	arg->op.op = token;
1242	arg->op.left = left;	1241	arg->op.left = left;
1243		1242
1244	set_op_prio(arg);	1243	set_op_prio(arg);
1245		1244
1246	right = malloc_or_die(sizeof(*right));	1245	right = malloc_or_die(sizeof(*right));
1247		1246
1248	type = read_token_item(&token);	1247	type = read_token_item(&token);
1249	*tok = token;	1248	*tok = token;
1250		1249
1251	/* could just be a type pointer */	1250	/* could just be a type pointer */
1252	if ((strcmp(arg->op.op, "*") == 0) &&	1251	if ((strcmp(arg->op.op, "*") == 0) &&
1253	type == EVENT_DELIM && (strcmp(token, ")") == 0)) {	1252	type == EVENT_DELIM && (strcmp(token, ")") == 0)) {
1254	if (left->type != PRINT_ATOM)	1253	if (left->type != PRINT_ATOM)
1255	die("bad pointer type");	1254	die("bad pointer type");
1256	left->atom.atom = realloc(left->atom.atom,	1255	left->atom.atom = realloc(left->atom.atom,
1257	sizeof(left->atom.atom) + 3);	1256	sizeof(left->atom.atom) + 3);
1258	strcat(left->atom.atom, " *");	1257	strcat(left->atom.atom, " *");
1259	arg = left;	1258	arg = left;
1260	free(arg);	1259	free(arg);
1261		1260
1262	return type;	1261	return type;
1263	}	1262	}
1264		1263
1265	type = process_arg_token(event, right, tok, type);	1264	type = process_arg_token(event, right, tok, type);
1266		1265
1267	arg->op.right = right;	1266	arg->op.right = right;
1268		1267
1269	} else if (strcmp(token, "[") == 0) {	1268	} else if (strcmp(token, "[") == 0) {
1270		1269
1271	left = malloc_or_die(sizeof(*left));	1270	left = malloc_or_die(sizeof(*left));
1272	left = arg;	1271	left = arg;
1273		1272
1274	arg->type = PRINT_OP;	1273	arg->type = PRINT_OP;
1275	arg->op.op = token;	1274	arg->op.op = token;
1276	arg->op.left = left;	1275	arg->op.left = left;
1277		1276
1278	arg->op.prio = 0;	1277	arg->op.prio = 0;
1279	type = process_array(event, arg, tok);	1278	type = process_array(event, arg, tok);
1280		1279
1281	} else {	1280	} else {
1282	warning("unknown op '%s'", token);	1281	warning("unknown op '%s'", token);
1283	event->flags \|= EVENT_FL_FAILED;	1282	event->flags \|= EVENT_FL_FAILED;
1284	/* the arg is now the left side */	1283	/* the arg is now the left side */
1285	return EVENT_NONE;	1284	return EVENT_NONE;
1286	}	1285	}
1287		1286
1288	if (type == EVENT_OP) {	1287	if (type == EVENT_OP) {
1289	int prio;	1288	int prio;
1290		1289
1291	/* higher prios need to be closer to the root */	1290	/* higher prios need to be closer to the root */
1292	prio = get_op_prio(*tok);	1291	prio = get_op_prio(*tok);
1293		1292
1294	if (prio > arg->op.prio)	1293	if (prio > arg->op.prio)
1295	return process_op(event, arg, tok);	1294	return process_op(event, arg, tok);
1296		1295
1297	return process_op(event, right, tok);	1296	return process_op(event, right, tok);
1298	}	1297	}
1299		1298
1300	return type;	1299	return type;
1301	}	1300	}
1302		1301
1303	static enum event_type	1302	static enum event_type
1304	process_entry(struct event event __unused, struct print_arg arg,	1303	process_entry(struct event event __unused, struct print_arg arg,
1305	char **tok)	1304	char **tok)
1306	{	1305	{
1307	enum event_type type;	1306	enum event_type type;
1308	char *field;	1307	char *field;
1309	char *token;	1308	char *token;
1310		1309
1311	if (read_expected(EVENT_OP, "->") < 0)	1310	if (read_expected(EVENT_OP, "->") < 0)
1312	return EVENT_ERROR;	1311	return EVENT_ERROR;
1313		1312
1314	if (read_expect_type(EVENT_ITEM, &token) < 0)	1313	if (read_expect_type(EVENT_ITEM, &token) < 0)
1315	goto fail;	1314	goto fail;
1316	field = token;	1315	field = token;
1317		1316
1318	arg->type = PRINT_FIELD;	1317	arg->type = PRINT_FIELD;
1319	arg->field.name = field;	1318	arg->field.name = field;
1320		1319
1321	if (is_flag_field) {	1320	if (is_flag_field) {
1322	arg->field.field = find_any_field(event, arg->field.name);	1321	arg->field.field = find_any_field(event, arg->field.name);
1323	arg->field.field->flags \|= FIELD_IS_FLAG;	1322	arg->field.field->flags \|= FIELD_IS_FLAG;
1324	is_flag_field = 0;	1323	is_flag_field = 0;
1325	} else if (is_symbolic_field) {	1324	} else if (is_symbolic_field) {
1326	arg->field.field = find_any_field(event, arg->field.name);	1325	arg->field.field = find_any_field(event, arg->field.name);
1327	arg->field.field->flags \|= FIELD_IS_SYMBOLIC;	1326	arg->field.field->flags \|= FIELD_IS_SYMBOLIC;
1328	is_symbolic_field = 0;	1327	is_symbolic_field = 0;
1329	}	1328	}
1330		1329
1331	type = read_token(&token);	1330	type = read_token(&token);
1332	*tok = token;	1331	*tok = token;
1333		1332
1334	return type;	1333	return type;
1335		1334
1336	fail:	1335	fail:
1337	free_token(token);	1336	free_token(token);
1338	return EVENT_ERROR;	1337	return EVENT_ERROR;
1339	}	1338	}
1340		1339
1341	static char arg_eval (struct print_arg arg);	1340	static char arg_eval (struct print_arg arg);
1342		1341
1343	static long long arg_num_eval(struct print_arg *arg)	1342	static long long arg_num_eval(struct print_arg *arg)
1344	{	1343	{
1345	long long left, right;	1344	long long left, right;
1346	long long val = 0;	1345	long long val = 0;
1347		1346
1348	switch (arg->type) {	1347	switch (arg->type) {
1349	case PRINT_ATOM:	1348	case PRINT_ATOM:
1350	val = strtoll(arg->atom.atom, NULL, 0);	1349	val = strtoll(arg->atom.atom, NULL, 0);
1351	break;	1350	break;
1352	case PRINT_TYPE:	1351	case PRINT_TYPE:
1353	val = arg_num_eval(arg->typecast.item);	1352	val = arg_num_eval(arg->typecast.item);
1354	break;	1353	break;
1355	case PRINT_OP:	1354	case PRINT_OP:
1356	switch (arg->op.op[0]) {	1355	switch (arg->op.op[0]) {
1357	case '\|':	1356	case '\|':
1358	left = arg_num_eval(arg->op.left);	1357	left = arg_num_eval(arg->op.left);
1359	right = arg_num_eval(arg->op.right);	1358	right = arg_num_eval(arg->op.right);
1360	if (arg->op.op[1])	1359	if (arg->op.op[1])
1361	val = left \|\| right;	1360	val = left \|\| right;
1362	else	1361	else
1363	val = left \| right;	1362	val = left \| right;
1364	break;	1363	break;
1365	case '&':	1364	case '&':
1366	left = arg_num_eval(arg->op.left);	1365	left = arg_num_eval(arg->op.left);
1367	right = arg_num_eval(arg->op.right);	1366	right = arg_num_eval(arg->op.right);
1368	if (arg->op.op[1])	1367	if (arg->op.op[1])
1369	val = left && right;	1368	val = left && right;
1370	else	1369	else
1371	val = left & right;	1370	val = left & right;
1372	break;	1371	break;
1373	case '<':	1372	case '<':
1374	left = arg_num_eval(arg->op.left);	1373	left = arg_num_eval(arg->op.left);
1375	right = arg_num_eval(arg->op.right);	1374	right = arg_num_eval(arg->op.right);
1376	switch (arg->op.op[1]) {	1375	switch (arg->op.op[1]) {
1377	case 0:	1376	case 0:
1378	val = left < right;	1377	val = left < right;
1379	break;	1378	break;
1380	case '<':	1379	case '<':
1381	val = left << right;	1380	val = left << right;
1382	break;	1381	break;
1383	case '=':	1382	case '=':
1384	val = left <= right;	1383	val = left <= right;
1385	break;	1384	break;
1386	default:	1385	default:
1387	die("unknown op '%s'", arg->op.op);	1386	die("unknown op '%s'", arg->op.op);
1388	}	1387	}
1389	break;	1388	break;
1390	case '>':	1389	case '>':
1391	left = arg_num_eval(arg->op.left);	1390	left = arg_num_eval(arg->op.left);
1392	right = arg_num_eval(arg->op.right);	1391	right = arg_num_eval(arg->op.right);
1393	switch (arg->op.op[1]) {	1392	switch (arg->op.op[1]) {
1394	case 0:	1393	case 0:
1395	val = left > right;	1394	val = left > right;
1396	break;	1395	break;
1397	case '>':	1396	case '>':
1398	val = left >> right;	1397	val = left >> right;
1399	break;	1398	break;
1400	case '=':	1399	case '=':
1401	val = left >= right;	1400	val = left >= right;
1402	break;	1401	break;
1403	default:	1402	default:
1404	die("unknown op '%s'", arg->op.op);	1403	die("unknown op '%s'", arg->op.op);
1405	}	1404	}
1406	break;	1405	break;
1407	case '=':	1406	case '=':
1408	left = arg_num_eval(arg->op.left);	1407	left = arg_num_eval(arg->op.left);
1409	right = arg_num_eval(arg->op.right);	1408	right = arg_num_eval(arg->op.right);
1410		1409
1411	if (arg->op.op[1] != '=')	1410	if (arg->op.op[1] != '=')
1412	die("unknown op '%s'", arg->op.op);	1411	die("unknown op '%s'", arg->op.op);
1413		1412
1414	val = left == right;	1413	val = left == right;
1415	break;	1414	break;
1416	case '!':	1415	case '!':
1417	left = arg_num_eval(arg->op.left);	1416	left = arg_num_eval(arg->op.left);
1418	right = arg_num_eval(arg->op.right);	1417	right = arg_num_eval(arg->op.right);
1419		1418
1420	switch (arg->op.op[1]) {	1419	switch (arg->op.op[1]) {
1421	case '=':	1420	case '=':
1422	val = left != right;	1421	val = left != right;
1423	break;	1422	break;
1424	default:	1423	default:
1425	die("unknown op '%s'", arg->op.op);	1424	die("unknown op '%s'", arg->op.op);
1426	}	1425	}
1427	break;	1426	break;
1428	default:	1427	default:
1429	die("unknown op '%s'", arg->op.op);	1428	die("unknown op '%s'", arg->op.op);
1430	}	1429	}
1431	break;	1430	break;
1432		1431
1433	case PRINT_NULL:	1432	case PRINT_NULL:
1434	case PRINT_FIELD ... PRINT_SYMBOL:	1433	case PRINT_FIELD ... PRINT_SYMBOL:
1435	case PRINT_STRING:	1434	case PRINT_STRING:
1436	default:	1435	default:
1437	die("invalid eval type %d", arg->type);	1436	die("invalid eval type %d", arg->type);
1438		1437
1439	}	1438	}
1440	return val;	1439	return val;
1441	}	1440	}
1442		1441
1443	static char arg_eval (struct print_arg arg)	1442	static char arg_eval (struct print_arg arg)
1444	{	1443	{
1445	long long val;	1444	long long val;
1446	static char buf[20];	1445	static char buf[20];
1447		1446
1448	switch (arg->type) {	1447	switch (arg->type) {
1449	case PRINT_ATOM:	1448	case PRINT_ATOM:
1450	return arg->atom.atom;	1449	return arg->atom.atom;
1451	case PRINT_TYPE:	1450	case PRINT_TYPE:
1452	return arg_eval(arg->typecast.item);	1451	return arg_eval(arg->typecast.item);
1453	case PRINT_OP:	1452	case PRINT_OP:
1454	val = arg_num_eval(arg);	1453	val = arg_num_eval(arg);
1455	sprintf(buf, "%lld", val);	1454	sprintf(buf, "%lld", val);
1456	return buf;	1455	return buf;
1457		1456
1458	case PRINT_NULL:	1457	case PRINT_NULL:
1459	case PRINT_FIELD ... PRINT_SYMBOL:	1458	case PRINT_FIELD ... PRINT_SYMBOL:
1460	case PRINT_STRING:	1459	case PRINT_STRING:
1461	default:	1460	default:
1462	die("invalid eval type %d", arg->type);	1461	die("invalid eval type %d", arg->type);
1463	break;	1462	break;
1464	}	1463	}
1465		1464
1466	return NULL;	1465	return NULL;
1467	}	1466	}
1468		1467
1469	static enum event_type	1468	static enum event_type
1470	process_fields(struct event event, struct print_flag_sym list, char *tok)	1469	process_fields(struct event event, struct print_flag_sym list, char *tok)
1471	{	1470	{
1472	enum event_type type;	1471	enum event_type type;
1473	struct print_arg *arg = NULL;	1472	struct print_arg *arg = NULL;
1474	struct print_flag_sym *field;	1473	struct print_flag_sym *field;
1475	char *token = NULL;	1474	char *token = NULL;
1476	char *value;	1475	char *value;
1477		1476
1478	do {	1477	do {
1479	free_token(token);	1478	free_token(token);
1480	type = read_token_item(&token);	1479	type = read_token_item(&token);
1481	if (test_type_token(type, token, EVENT_OP, "{"))	1480	if (test_type_token(type, token, EVENT_OP, "{"))
1482	break;	1481	break;
1483		1482
1484	arg = malloc_or_die(sizeof(*arg));	1483	arg = malloc_or_die(sizeof(*arg));
1485		1484
1486	free_token(token);	1485	free_token(token);
1487	type = process_arg(event, arg, &token);	1486	type = process_arg(event, arg, &token);
1488	if (test_type_token(type, token, EVENT_DELIM, ","))	1487	if (test_type_token(type, token, EVENT_DELIM, ","))
1489	goto out_free;	1488	goto out_free;
1490		1489
1491	field = malloc_or_die(sizeof(*field));	1490	field = malloc_or_die(sizeof(*field));
1492	memset(field, 0, sizeof(*field));	1491	memset(field, 0, sizeof(*field));
1493		1492
1494	value = arg_eval(arg);	1493	value = arg_eval(arg);
1495	field->value = strdup(value);	1494	field->value = strdup(value);
1496		1495
1497	free_token(token);	1496	free_token(token);
1498	type = process_arg(event, arg, &token);	1497	type = process_arg(event, arg, &token);
1499	if (test_type_token(type, token, EVENT_OP, "}"))	1498	if (test_type_token(type, token, EVENT_OP, "}"))
1500	goto out_free;	1499	goto out_free;
1501		1500
1502	value = arg_eval(arg);	1501	value = arg_eval(arg);
1503	field->str = strdup(value);	1502	field->str = strdup(value);
1504	free_arg(arg);	1503	free_arg(arg);
1505	arg = NULL;	1504	arg = NULL;
1506		1505
1507	*list = field;	1506	*list = field;
1508	list = &field->next;	1507	list = &field->next;
1509		1508
1510	free_token(token);	1509	free_token(token);
1511	type = read_token_item(&token);	1510	type = read_token_item(&token);
1512	} while (type == EVENT_DELIM && strcmp(token, ",") == 0);	1511	} while (type == EVENT_DELIM && strcmp(token, ",") == 0);
1513		1512
1514	*tok = token;	1513	*tok = token;
1515	return type;	1514	return type;
1516		1515
1517	out_free:	1516	out_free:
1518	free_arg(arg);	1517	free_arg(arg);
1519	free_token(token);	1518	free_token(token);
1520		1519
1521	return EVENT_ERROR;	1520	return EVENT_ERROR;
1522	}	1521	}
1523		1522
1524	static enum event_type	1523	static enum event_type
1525	process_flags(struct event event, struct print_arg arg, char **tok)	1524	process_flags(struct event event, struct print_arg arg, char **tok)
1526	{	1525	{
1527	struct print_arg *field;	1526	struct print_arg *field;
1528	enum event_type type;	1527	enum event_type type;
1529	char *token;	1528	char *token;
1530		1529
1531	memset(arg, 0, sizeof(*arg));	1530	memset(arg, 0, sizeof(*arg));
1532	arg->type = PRINT_FLAGS;	1531	arg->type = PRINT_FLAGS;
1533		1532
1534	if (read_expected_item(EVENT_DELIM, "(") < 0)	1533	if (read_expected_item(EVENT_DELIM, "(") < 0)
1535	return EVENT_ERROR;	1534	return EVENT_ERROR;
1536		1535
1537	field = malloc_or_die(sizeof(*field));	1536	field = malloc_or_die(sizeof(*field));
1538		1537
1539	type = process_arg(event, field, &token);	1538	type = process_arg(event, field, &token);
1540	while (type == EVENT_OP)	1539	while (type == EVENT_OP)
1541	type = process_op(event, field, &token);	1540	type = process_op(event, field, &token);
1542	if (test_type_token(type, token, EVENT_DELIM, ","))	1541	if (test_type_token(type, token, EVENT_DELIM, ","))
1543	goto out_free;	1542	goto out_free;
1544		1543
1545	arg->flags.field = field;	1544	arg->flags.field = field;
1546		1545
1547	type = read_token_item(&token);	1546	type = read_token_item(&token);
1548	if (event_item_type(type)) {	1547	if (event_item_type(type)) {
1549	arg->flags.delim = token;	1548	arg->flags.delim = token;
1550	type = read_token_item(&token);	1549	type = read_token_item(&token);
1551	}	1550	}
1552		1551
1553	if (test_type_token(type, token, EVENT_DELIM, ","))	1552	if (test_type_token(type, token, EVENT_DELIM, ","))
1554	goto out_free;	1553	goto out_free;
1555		1554
1556	type = process_fields(event, &arg->flags.flags, &token);	1555	type = process_fields(event, &arg->flags.flags, &token);
1557	if (test_type_token(type, token, EVENT_DELIM, ")"))	1556	if (test_type_token(type, token, EVENT_DELIM, ")"))
1558	goto out_free;	1557	goto out_free;
1559		1558
1560	free_token(token);	1559	free_token(token);
1561	type = read_token_item(tok);	1560	type = read_token_item(tok);
1562	return type;	1561	return type;
1563		1562
1564	out_free:	1563	out_free:
1565	free_token(token);	1564	free_token(token);
1566	return EVENT_ERROR;	1565	return EVENT_ERROR;
1567	}	1566	}
1568		1567
1569	static enum event_type	1568	static enum event_type
1570	process_symbols(struct event event, struct print_arg arg, char **tok)	1569	process_symbols(struct event event, struct print_arg arg, char **tok)
1571	{	1570	{
1572	struct print_arg *field;	1571	struct print_arg *field;
1573	enum event_type type;	1572	enum event_type type;
1574	char *token;	1573	char *token;
1575		1574
1576	memset(arg, 0, sizeof(*arg));	1575	memset(arg, 0, sizeof(*arg));
1577	arg->type = PRINT_SYMBOL;	1576	arg->type = PRINT_SYMBOL;
1578		1577
1579	if (read_expected_item(EVENT_DELIM, "(") < 0)	1578	if (read_expected_item(EVENT_DELIM, "(") < 0)
1580	return EVENT_ERROR;	1579	return EVENT_ERROR;
1581		1580
1582	field = malloc_or_die(sizeof(*field));	1581	field = malloc_or_die(sizeof(*field));
1583		1582
1584	type = process_arg(event, field, &token);	1583	type = process_arg(event, field, &token);
1585	if (test_type_token(type, token, EVENT_DELIM, ","))	1584	if (test_type_token(type, token, EVENT_DELIM, ","))
1586	goto out_free;	1585	goto out_free;
1587		1586
1588	arg->symbol.field = field;	1587	arg->symbol.field = field;
1589		1588
1590	type = process_fields(event, &arg->symbol.symbols, &token);	1589	type = process_fields(event, &arg->symbol.symbols, &token);
1591	if (test_type_token(type, token, EVENT_DELIM, ")"))	1590	if (test_type_token(type, token, EVENT_DELIM, ")"))
1592	goto out_free;	1591	goto out_free;
1593		1592
1594	free_token(token);	1593	free_token(token);
1595	type = read_token_item(tok);	1594	type = read_token_item(tok);
1596	return type;	1595	return type;
1597		1596
1598	out_free:	1597	out_free:
1599	free_token(token);	1598	free_token(token);
1600	return EVENT_ERROR;	1599	return EVENT_ERROR;
1601	}	1600	}
1602		1601
1603	static enum event_type	1602	static enum event_type
1604	process_paren(struct event event, struct print_arg arg, char **tok)	1603	process_paren(struct event event, struct print_arg arg, char **tok)
1605	{	1604	{
1606	struct print_arg *item_arg;	1605	struct print_arg *item_arg;
1607	enum event_type type;	1606	enum event_type type;
1608	char *token;	1607	char *token;
1609		1608
1610	type = process_arg(event, arg, &token);	1609	type = process_arg(event, arg, &token);
1611		1610
1612	if (type == EVENT_ERROR)	1611	if (type == EVENT_ERROR)
1613	return EVENT_ERROR;	1612	return EVENT_ERROR;
1614		1613
1615	if (type == EVENT_OP)	1614	if (type == EVENT_OP)
1616	type = process_op(event, arg, &token);	1615	type = process_op(event, arg, &token);
1617		1616
1618	if (type == EVENT_ERROR)	1617	if (type == EVENT_ERROR)
1619	return EVENT_ERROR;	1618	return EVENT_ERROR;
1620		1619
1621	if (test_type_token(type, token, EVENT_DELIM, ")")) {	1620	if (test_type_token(type, token, EVENT_DELIM, ")")) {
1622	free_token(token);	1621	free_token(token);
1623	return EVENT_ERROR;	1622	return EVENT_ERROR;
1624	}	1623	}
1625		1624
1626	free_token(token);	1625	free_token(token);
1627	type = read_token_item(&token);	1626	type = read_token_item(&token);
1628		1627
1629	/*	1628	/*
1630	* If the next token is an item or another open paren, then	1629	* If the next token is an item or another open paren, then
1631	* this was a typecast.	1630	* this was a typecast.
1632	*/	1631	*/
1633	if (event_item_type(type) \|\|	1632	if (event_item_type(type) \|\|
1634	(type == EVENT_DELIM && strcmp(token, "(") == 0)) {	1633	(type == EVENT_DELIM && strcmp(token, "(") == 0)) {
1635		1634
1636	/* make this a typecast and contine */	1635	/* make this a typecast and contine */
1637		1636
1638	/* prevous must be an atom */	1637	/* prevous must be an atom */
1639	if (arg->type != PRINT_ATOM)	1638	if (arg->type != PRINT_ATOM)
1640	die("previous needed to be PRINT_ATOM");	1639	die("previous needed to be PRINT_ATOM");
1641		1640
1642	item_arg = malloc_or_die(sizeof(*item_arg));	1641	item_arg = malloc_or_die(sizeof(*item_arg));
1643		1642
1644	arg->type = PRINT_TYPE;	1643	arg->type = PRINT_TYPE;
1645	arg->typecast.type = arg->atom.atom;	1644	arg->typecast.type = arg->atom.atom;
1646	arg->typecast.item = item_arg;	1645	arg->typecast.item = item_arg;
1647	type = process_arg_token(event, item_arg, &token, type);	1646	type = process_arg_token(event, item_arg, &token, type);
1648		1647
1649	}	1648	}
1650		1649
1651	*tok = token;	1650	*tok = token;
1652	return type;	1651	return type;
1653	}	1652	}
1654		1653
1655		1654
1656	static enum event_type	1655	static enum event_type
1657	process_str(struct event event __unused, struct print_arg arg, char **tok)	1656	process_str(struct event event __unused, struct print_arg arg, char **tok)
1658	{	1657	{
1659	enum event_type type;	1658	enum event_type type;
1660	char *token;	1659	char *token;
1661		1660
1662	if (read_expected(EVENT_DELIM, "(") < 0)	1661	if (read_expected(EVENT_DELIM, "(") < 0)
1663	return EVENT_ERROR;	1662	return EVENT_ERROR;
1664		1663
1665	if (read_expect_type(EVENT_ITEM, &token) < 0)	1664	if (read_expect_type(EVENT_ITEM, &token) < 0)
1666	goto fail;	1665	goto fail;
1667		1666
1668	arg->type = PRINT_STRING;	1667	arg->type = PRINT_STRING;
1669	arg->string.string = token;	1668	arg->string.string = token;
1670	arg->string.offset = -1;	1669	arg->string.offset = -1;
1671		1670
1672	if (read_expected(EVENT_DELIM, ")") < 0)	1671	if (read_expected(EVENT_DELIM, ")") < 0)
1673	return EVENT_ERROR;	1672	return EVENT_ERROR;
1674		1673
1675	type = read_token(&token);	1674	type = read_token(&token);
1676	*tok = token;	1675	*tok = token;
1677		1676
1678	return type;	1677	return type;
1679	fail:	1678	fail:
1680	free_token(token);	1679	free_token(token);
1681	return EVENT_ERROR;	1680	return EVENT_ERROR;
1682	}	1681	}
1683		1682
1684	enum event_type	1683	enum event_type
1685	process_arg_token(struct event event, struct print_arg arg,	1684	process_arg_token(struct event event, struct print_arg arg,
1686	char **tok, enum event_type type)	1685	char **tok, enum event_type type)
1687	{	1686	{
1688	char *token;	1687	char *token;
1689	char *atom;	1688	char *atom;
1690		1689
1691	token = *tok;	1690	token = *tok;
1692		1691
1693	switch (type) {	1692	switch (type) {
1694	case EVENT_ITEM:	1693	case EVENT_ITEM:
1695	if (strcmp(token, "REC") == 0) {	1694	if (strcmp(token, "REC") == 0) {
1696	free_token(token);	1695	free_token(token);
1697	type = process_entry(event, arg, &token);	1696	type = process_entry(event, arg, &token);
1698	} else if (strcmp(token, "__print_flags") == 0) {	1697	} else if (strcmp(token, "__print_flags") == 0) {
1699	free_token(token);	1698	free_token(token);
1700	is_flag_field = 1;	1699	is_flag_field = 1;
1701	type = process_flags(event, arg, &token);	1700	type = process_flags(event, arg, &token);
1702	} else if (strcmp(token, "__print_symbolic") == 0) {	1701	} else if (strcmp(token, "__print_symbolic") == 0) {
1703	free_token(token);	1702	free_token(token);
1704	is_symbolic_field = 1;	1703	is_symbolic_field = 1;
1705	type = process_symbols(event, arg, &token);	1704	type = process_symbols(event, arg, &token);
1706	} else if (strcmp(token, "__get_str") == 0) {	1705	} else if (strcmp(token, "__get_str") == 0) {
1707	free_token(token);	1706	free_token(token);
1708	type = process_str(event, arg, &token);	1707	type = process_str(event, arg, &token);
1709	} else {	1708	} else {
1710	atom = token;	1709	atom = token;
1711	/* test the next token */	1710	/* test the next token */
1712	type = read_token_item(&token);	1711	type = read_token_item(&token);
1713		1712
1714	/* atoms can be more than one token long */	1713	/* atoms can be more than one token long */
1715	while (type == EVENT_ITEM) {	1714	while (type == EVENT_ITEM) {
1716	atom = realloc(atom, strlen(atom) + strlen(token) + 2);	1715	atom = realloc(atom, strlen(atom) + strlen(token) + 2);
1717	strcat(atom, " ");	1716	strcat(atom, " ");
1718	strcat(atom, token);	1717	strcat(atom, token);
1719	free_token(token);	1718	free_token(token);
1720	type = read_token_item(&token);	1719	type = read_token_item(&token);
1721	}	1720	}
1722		1721
1723	/* todo, test for function */	1722	/* todo, test for function */
1724		1723
1725	arg->type = PRINT_ATOM;	1724	arg->type = PRINT_ATOM;
1726	arg->atom.atom = atom;	1725	arg->atom.atom = atom;
1727	}	1726	}
1728	break;	1727	break;
1729	case EVENT_DQUOTE:	1728	case EVENT_DQUOTE:
1730	case EVENT_SQUOTE:	1729	case EVENT_SQUOTE:
1731	arg->type = PRINT_ATOM;	1730	arg->type = PRINT_ATOM;
1732	arg->atom.atom = token;	1731	arg->atom.atom = token;
1733	type = read_token_item(&token);	1732	type = read_token_item(&token);
1734	break;	1733	break;
1735	case EVENT_DELIM:	1734	case EVENT_DELIM:
1736	if (strcmp(token, "(") == 0) {	1735	if (strcmp(token, "(") == 0) {
1737	free_token(token);	1736	free_token(token);
1738	type = process_paren(event, arg, &token);	1737	type = process_paren(event, arg, &token);
1739	break;	1738	break;
1740	}	1739	}
1741	case EVENT_OP:	1740	case EVENT_OP:
1742	/* handle single ops */	1741	/* handle single ops */
1743	arg->type = PRINT_OP;	1742	arg->type = PRINT_OP;
1744	arg->op.op = token;	1743	arg->op.op = token;
1745	arg->op.left = NULL;	1744	arg->op.left = NULL;
1746	type = process_op(event, arg, &token);	1745	type = process_op(event, arg, &token);
1747		1746
1748	break;	1747	break;
1749		1748
1750	case EVENT_ERROR ... EVENT_NEWLINE:	1749	case EVENT_ERROR ... EVENT_NEWLINE:
1751	default:	1750	default:
1752	die("unexpected type %d", type);	1751	die("unexpected type %d", type);
1753	}	1752	}
1754	*tok = token;	1753	*tok = token;
1755		1754
1756	return type;	1755	return type;
1757	}	1756	}
1758		1757
1759	static int event_read_print_args(struct event event, struct print_arg *list)	1758	static int event_read_print_args(struct event event, struct print_arg *list)
1760	{	1759	{
1761	enum event_type type = EVENT_ERROR;	1760	enum event_type type = EVENT_ERROR;
1762	struct print_arg *arg;	1761	struct print_arg *arg;
1763	char *token;	1762	char *token;
1764	int args = 0;	1763	int args = 0;
1765		1764
1766	do {	1765	do {
1767	if (type == EVENT_NEWLINE) {	1766	if (type == EVENT_NEWLINE) {
1768	free_token(token);	1767	free_token(token);
1769	type = read_token_item(&token);	1768	type = read_token_item(&token);
1770	continue;	1769	continue;
1771	}	1770	}
1772		1771
1773	arg = malloc_or_die(sizeof(*arg));	1772	arg = malloc_or_die(sizeof(*arg));
1774	memset(arg, 0, sizeof(*arg));	1773	memset(arg, 0, sizeof(*arg));
1775		1774
1776	type = process_arg(event, arg, &token);	1775	type = process_arg(event, arg, &token);
1777		1776
1778	if (type == EVENT_ERROR) {	1777	if (type == EVENT_ERROR) {
1779	free_arg(arg);	1778	free_arg(arg);
1780	return -1;	1779	return -1;
1781	}	1780	}
1782		1781
1783	*list = arg;	1782	*list = arg;
1784	args++;	1783	args++;
1785		1784
1786	if (type == EVENT_OP) {	1785	if (type == EVENT_OP) {
1787	type = process_op(event, arg, &token);	1786	type = process_op(event, arg, &token);
1788	list = &arg->next;	1787	list = &arg->next;
1789	continue;	1788	continue;
1790	}	1789	}
1791		1790
1792	if (type == EVENT_DELIM && strcmp(token, ",") == 0) {	1791	if (type == EVENT_DELIM && strcmp(token, ",") == 0) {
1793	free_token(token);	1792	free_token(token);
1794	*list = arg;	1793	*list = arg;
1795	list = &arg->next;	1794	list = &arg->next;
1796	continue;	1795	continue;
1797	}	1796	}
1798	break;	1797	break;
1799	} while (type != EVENT_NONE);	1798	} while (type != EVENT_NONE);
1800		1799
1801	if (type != EVENT_NONE)	1800	if (type != EVENT_NONE)
1802	free_token(token);	1801	free_token(token);
1803		1802
1804	return args;	1803	return args;
1805	}	1804	}
1806		1805
1807	static int event_read_print(struct event *event)	1806	static int event_read_print(struct event *event)
1808	{	1807	{
1809	enum event_type type;	1808	enum event_type type;
1810	char *token;	1809	char *token;
1811	int ret;	1810	int ret;
1812		1811
1813	if (read_expected_item(EVENT_ITEM, "print") < 0)	1812	if (read_expected_item(EVENT_ITEM, "print") < 0)
1814	return -1;	1813	return -1;
1815		1814
1816	if (read_expected(EVENT_ITEM, "fmt") < 0)	1815	if (read_expected(EVENT_ITEM, "fmt") < 0)
1817	return -1;	1816	return -1;
1818		1817
1819	if (read_expected(EVENT_OP, ":") < 0)	1818	if (read_expected(EVENT_OP, ":") < 0)
1820	return -1;	1819	return -1;
1821		1820
1822	if (read_expect_type(EVENT_DQUOTE, &token) < 0)	1821	if (read_expect_type(EVENT_DQUOTE, &token) < 0)
1823	goto fail;	1822	goto fail;
1824		1823
1825	concat:	1824	concat:
1826	event->print_fmt.format = token;	1825	event->print_fmt.format = token;
1827	event->print_fmt.args = NULL;	1826	event->print_fmt.args = NULL;
1828		1827
1829	/* ok to have no arg */	1828	/* ok to have no arg */
1830	type = read_token_item(&token);	1829	type = read_token_item(&token);
1831		1830
1832	if (type == EVENT_NONE)	1831	if (type == EVENT_NONE)
1833	return 0;	1832	return 0;
1834		1833
1835	/* Handle concatination of print lines */	1834	/* Handle concatination of print lines */
1836	if (type == EVENT_DQUOTE) {	1835	if (type == EVENT_DQUOTE) {
1837	char *cat;	1836	char *cat;
1838		1837
1839	cat = malloc_or_die(strlen(event->print_fmt.format) +	1838	cat = malloc_or_die(strlen(event->print_fmt.format) +
1840	strlen(token) + 1);	1839	strlen(token) + 1);
1841	strcpy(cat, event->print_fmt.format);	1840	strcpy(cat, event->print_fmt.format);
1842	strcat(cat, token);	1841	strcat(cat, token);
1843	free_token(token);	1842	free_token(token);
1844	free_token(event->print_fmt.format);	1843	free_token(event->print_fmt.format);
1845	event->print_fmt.format = NULL;	1844	event->print_fmt.format = NULL;
1846	token = cat;	1845	token = cat;
1847	goto concat;	1846	goto concat;
1848	}	1847	}
1849		1848
1850	if (test_type_token(type, token, EVENT_DELIM, ","))	1849	if (test_type_token(type, token, EVENT_DELIM, ","))
1851	goto fail;	1850	goto fail;
1852		1851
1853	free_token(token);	1852	free_token(token);
1854		1853
1855	ret = event_read_print_args(event, &event->print_fmt.args);	1854	ret = event_read_print_args(event, &event->print_fmt.args);
1856	if (ret < 0)	1855	if (ret < 0)
1857	return -1;	1856	return -1;
1858		1857
1859	return ret;	1858	return ret;
1860		1859
1861	fail:	1860	fail:
1862	free_token(token);	1861	free_token(token);
1863	return -1;	1862	return -1;
1864	}	1863	}
1865		1864
1866	static struct format_field *	1865	static struct format_field *
1867	find_common_field(struct event event, const char name)	1866	find_common_field(struct event event, const char name)
1868	{	1867	{
1869	struct format_field *format;	1868	struct format_field *format;
1870		1869
1871	for (format = event->format.common_fields;	1870	for (format = event->format.common_fields;
1872	format; format = format->next) {	1871	format; format = format->next) {
1873	if (strcmp(format->name, name) == 0)	1872	if (strcmp(format->name, name) == 0)
1874	break;	1873	break;
1875	}	1874	}
1876		1875
1877	return format;	1876	return format;
1878	}	1877	}
1879		1878
1880	static struct format_field *	1879	static struct format_field *
1881	find_field(struct event event, const char name)	1880	find_field(struct event event, const char name)
1882	{	1881	{
1883	struct format_field *format;	1882	struct format_field *format;
1884		1883
1885	for (format = event->format.fields;	1884	for (format = event->format.fields;
1886	format; format = format->next) {	1885	format; format = format->next) {
1887	if (strcmp(format->name, name) == 0)	1886	if (strcmp(format->name, name) == 0)
1888	break;	1887	break;
1889	}	1888	}
1890		1889
1891	return format;	1890	return format;
1892	}	1891	}
1893		1892
1894	static struct format_field *	1893	static struct format_field *
1895	find_any_field(struct event event, const char name)	1894	find_any_field(struct event event, const char name)
1896	{	1895	{
1897	struct format_field *format;	1896	struct format_field *format;
1898		1897
1899	format = find_common_field(event, name);	1898	format = find_common_field(event, name);
1900	if (format)	1899	if (format)
1901	return format;	1900	return format;
1902	return find_field(event, name);	1901	return find_field(event, name);
1903	}	1902	}
1904		1903
1905	unsigned long long read_size(void *ptr, int size)	1904	unsigned long long read_size(void *ptr, int size)
1906	{	1905	{
1907	switch (size) {	1906	switch (size) {
1908	case 1:	1907	case 1:
1909	return (unsigned char )ptr;	1908	return (unsigned char )ptr;
1910	case 2:	1909	case 2:
1911	return data2host2(ptr);	1910	return data2host2(ptr);
1912	case 4:	1911	case 4:
1913	return data2host4(ptr);	1912	return data2host4(ptr);
1914	case 8:	1913	case 8:
1915	return data2host8(ptr);	1914	return data2host8(ptr);
1916	default:	1915	default:
1917	/* BUG! */	1916	/* BUG! */
1918	return 0;	1917	return 0;
1919	}	1918	}
1920	}	1919	}
1921		1920
1922	unsigned long long	1921	unsigned long long
1923	raw_field_value(struct event event, const char name, void *data)	1922	raw_field_value(struct event event, const char name, void *data)
1924	{	1923	{
1925	struct format_field *field;	1924	struct format_field *field;
1926		1925
1927	field = find_any_field(event, name);	1926	field = find_any_field(event, name);
1928	if (!field)	1927	if (!field)
1929	return 0ULL;	1928	return 0ULL;
1930		1929
1931	return read_size(data + field->offset, field->size);	1930	return read_size(data + field->offset, field->size);
1932	}	1931	}
1933		1932
1934	void raw_field_ptr(struct event event, const char name, void data)	1933	void raw_field_ptr(struct event event, const char name, void data)
1935	{	1934	{
1936	struct format_field *field;	1935	struct format_field *field;
1937		1936
1938	field = find_any_field(event, name);	1937	field = find_any_field(event, name);
1939	if (!field)	1938	if (!field)
1940	return NULL;	1939	return NULL;
1941		1940
1942	if (field->flags & FIELD_IS_DYNAMIC) {	1941	if (field->flags & FIELD_IS_DYNAMIC) {
1943	int offset;	1942	int offset;
1944		1943
1945	offset = (int )(data + field->offset);	1944	offset = (int )(data + field->offset);
1946	offset &= 0xffff;	1945	offset &= 0xffff;
1947		1946
1948	return data + offset;	1947	return data + offset;
1949	}	1948	}
1950		1949
1951	return data + field->offset;	1950	return data + field->offset;
1952	}	1951	}
1953		1952
1954	static int get_common_info(const char type, int offset, int *size)	1953	static int get_common_info(const char type, int offset, int *size)
1955	{	1954	{
1956	struct event *event;	1955	struct event *event;
1957	struct format_field *field;	1956	struct format_field *field;
1958		1957
1959	/*	1958	/*
1960	* All events should have the same common elements.	1959	* All events should have the same common elements.
1961	* Pick any event to find where the type is;	1960	* Pick any event to find where the type is;
1962	*/	1961	*/
1963	if (!event_list)	1962	if (!event_list)
1964	die("no event_list!");	1963	die("no event_list!");
1965		1964
1966	event = event_list;	1965	event = event_list;
1967	field = find_common_field(event, type);	1966	field = find_common_field(event, type);
1968	if (!field)	1967	if (!field)
1969	die("field '%s' not found", type);	1968	die("field '%s' not found", type);
1970		1969
1971	*offset = field->offset;	1970	*offset = field->offset;
1972	*size = field->size;	1971	*size = field->size;
1973		1972
1974	return 0;	1973	return 0;
1975	}	1974	}
1976		1975
1977	static int __parse_common(void data, int size, int *offset,	1976	static int __parse_common(void data, int size, int *offset,
1978	const char *name)	1977	const char *name)
1979	{	1978	{
1980	int ret;	1979	int ret;
1981		1980
1982	if (!*size) {	1981	if (!*size) {
1983	ret = get_common_info(name, offset, size);	1982	ret = get_common_info(name, offset, size);
1984	if (ret < 0)	1983	if (ret < 0)
1985	return ret;	1984	return ret;
1986	}	1985	}
1987	return read_size(data + offset, size);	1986	return read_size(data + offset, size);
1988	}	1987	}
1989		1988
1990	int trace_parse_common_type(void *data)	1989	int trace_parse_common_type(void *data)
1991	{	1990	{
1992	static int type_offset;	1991	static int type_offset;
1993	static int type_size;	1992	static int type_size;
1994		1993
1995	return __parse_common(data, &type_size, &type_offset,	1994	return __parse_common(data, &type_size, &type_offset,
1996	"common_type");	1995	"common_type");
1997	}	1996	}
1998		1997
1999	int trace_parse_common_pid(void *data)	1998	int trace_parse_common_pid(void *data)
2000	{	1999	{
2001	static int pid_offset;	2000	static int pid_offset;
2002	static int pid_size;	2001	static int pid_size;
2003		2002
2004	return __parse_common(data, &pid_size, &pid_offset,	2003	return __parse_common(data, &pid_size, &pid_offset,
2005	"common_pid");	2004	"common_pid");
2006	}	2005	}
2007		2006
2008	int parse_common_pc(void *data)	2007	int parse_common_pc(void *data)
2009	{	2008	{
2010	static int pc_offset;	2009	static int pc_offset;
2011	static int pc_size;	2010	static int pc_size;
2012		2011
2013	return __parse_common(data, &pc_size, &pc_offset,	2012	return __parse_common(data, &pc_size, &pc_offset,
2014	"common_preempt_count");	2013	"common_preempt_count");
2015	}	2014	}
2016		2015
2017	int parse_common_flags(void *data)	2016	int parse_common_flags(void *data)
2018	{	2017	{
2019	static int flags_offset;	2018	static int flags_offset;
2020	static int flags_size;	2019	static int flags_size;
2021		2020
2022	return __parse_common(data, &flags_size, &flags_offset,	2021	return __parse_common(data, &flags_size, &flags_offset,
2023	"common_flags");	2022	"common_flags");
2024	}	2023	}
2025		2024
2026	int parse_common_lock_depth(void *data)	2025	int parse_common_lock_depth(void *data)
2027	{	2026	{
2028	static int ld_offset;	2027	static int ld_offset;
2029	static int ld_size;	2028	static int ld_size;
2030	int ret;	2029	int ret;
2031		2030
2032	ret = __parse_common(data, &ld_size, &ld_offset,	2031	ret = __parse_common(data, &ld_size, &ld_offset,
2033	"common_lock_depth");	2032	"common_lock_depth");
2034	if (ret < 0)	2033	if (ret < 0)
2035	return -1;	2034	return -1;
2036		2035
2037	return ret;	2036	return ret;
2038	}	2037	}
2039		2038
2040	struct event *trace_find_event(int id)	2039	struct event *trace_find_event(int id)
2041	{	2040	{
2042	struct event *event;	2041	struct event *event;
2043		2042
2044	for (event = event_list; event; event = event->next) {	2043	for (event = event_list; event; event = event->next) {
2045	if (event->id == id)	2044	if (event->id == id)
2046	break;	2045	break;
2047	}	2046	}
2048	return event;	2047	return event;
2049	}	2048	}
2050		2049
2051	struct event trace_find_next_event(struct event event)	2050	struct event trace_find_next_event(struct event event)
2052	{	2051	{
2053	if (!event)	2052	if (!event)
2054	return event_list;	2053	return event_list;
2055		2054
2056	return event->next;	2055	return event->next;
2057	}	2056	}
2058		2057
2059	static unsigned long long eval_num_arg(void *data, int size,	2058	static unsigned long long eval_num_arg(void *data, int size,
2060	struct event event, struct print_arg arg)	2059	struct event event, struct print_arg arg)
2061	{	2060	{
2062	unsigned long long val = 0;	2061	unsigned long long val = 0;
2063	unsigned long long left, right;	2062	unsigned long long left, right;
2064	struct print_arg *larg;	2063	struct print_arg *larg;
2065		2064
2066	switch (arg->type) {	2065	switch (arg->type) {
2067	case PRINT_NULL:	2066	case PRINT_NULL:
2068	/* ?? */	2067	/* ?? */
2069	return 0;	2068	return 0;
2070	case PRINT_ATOM:	2069	case PRINT_ATOM:
2071	return strtoull(arg->atom.atom, NULL, 0);	2070	return strtoull(arg->atom.atom, NULL, 0);
2072	case PRINT_FIELD:	2071	case PRINT_FIELD:
2073	if (!arg->field.field) {	2072	if (!arg->field.field) {
2074	arg->field.field = find_any_field(event, arg->field.name);	2073	arg->field.field = find_any_field(event, arg->field.name);
2075	if (!arg->field.field)	2074	if (!arg->field.field)
2076	die("field %s not found", arg->field.name);	2075	die("field %s not found", arg->field.name);
2077	}	2076	}
2078	/* must be a number */	2077	/* must be a number */
2079	val = read_size(data + arg->field.field->offset,	2078	val = read_size(data + arg->field.field->offset,
2080	arg->field.field->size);	2079	arg->field.field->size);
2081	break;	2080	break;
2082	case PRINT_FLAGS:	2081	case PRINT_FLAGS:
2083	case PRINT_SYMBOL:	2082	case PRINT_SYMBOL:
2084	break;	2083	break;
2085	case PRINT_TYPE:	2084	case PRINT_TYPE:
2086	return eval_num_arg(data, size, event, arg->typecast.item);	2085	return eval_num_arg(data, size, event, arg->typecast.item);
2087	case PRINT_STRING:	2086	case PRINT_STRING:
2088	return 0;	2087	return 0;
2089	break;	2088	break;
2090	case PRINT_OP:	2089	case PRINT_OP:
2091	if (strcmp(arg->op.op, "[") == 0) {	2090	if (strcmp(arg->op.op, "[") == 0) {
2092	/*	2091	/*
2093	* Arrays are special, since we don't want	2092	* Arrays are special, since we don't want
2094	* to read the arg as is.	2093	* to read the arg as is.
2095	*/	2094	*/
2096	if (arg->op.left->type != PRINT_FIELD)	2095	if (arg->op.left->type != PRINT_FIELD)
2097	goto default_op; /* oops, all bets off */	2096	goto default_op; /* oops, all bets off */
2098	larg = arg->op.left;	2097	larg = arg->op.left;
2099	if (!larg->field.field) {	2098	if (!larg->field.field) {
2100	larg->field.field =	2099	larg->field.field =
2101	find_any_field(event, larg->field.name);	2100	find_any_field(event, larg->field.name);
2102	if (!larg->field.field)	2101	if (!larg->field.field)
2103	die("field %s not found", larg->field.name);	2102	die("field %s not found", larg->field.name);
2104	}	2103	}
2105	right = eval_num_arg(data, size, event, arg->op.right);	2104	right = eval_num_arg(data, size, event, arg->op.right);
2106	val = read_size(data + larg->field.field->offset +	2105	val = read_size(data + larg->field.field->offset +
2107	right * long_size, long_size);	2106	right * long_size, long_size);
2108	break;	2107	break;
2109	}	2108	}
2110	default_op:	2109	default_op:
2111	left = eval_num_arg(data, size, event, arg->op.left);	2110	left = eval_num_arg(data, size, event, arg->op.left);
2112	right = eval_num_arg(data, size, event, arg->op.right);	2111	right = eval_num_arg(data, size, event, arg->op.right);
2113	switch (arg->op.op[0]) {	2112	switch (arg->op.op[0]) {
2114	case '\|':	2113	case '\|':
2115	if (arg->op.op[1])	2114	if (arg->op.op[1])
2116	val = left \|\| right;	2115	val = left \|\| right;
2117	else	2116	else
2118	val = left \| right;	2117	val = left \| right;
2119	break;	2118	break;
2120	case '&':	2119	case '&':
2121	if (arg->op.op[1])	2120	if (arg->op.op[1])
2122	val = left && right;	2121	val = left && right;
2123	else	2122	else
2124	val = left & right;	2123	val = left & right;
2125	break;	2124	break;
2126	case '<':	2125	case '<':
2127	switch (arg->op.op[1]) {	2126	switch (arg->op.op[1]) {
2128	case 0:	2127	case 0:
2129	val = left < right;	2128	val = left < right;
2130	break;	2129	break;
2131	case '<':	2130	case '<':
2132	val = left << right;	2131	val = left << right;
2133	break;	2132	break;
2134	case '=':	2133	case '=':
2135	val = left <= right;	2134	val = left <= right;
2136	break;	2135	break;
2137	default:	2136	default:
2138	die("unknown op '%s'", arg->op.op);	2137	die("unknown op '%s'", arg->op.op);
2139	}	2138	}
2140	break;	2139	break;
2141	case '>':	2140	case '>':
2142	switch (arg->op.op[1]) {	2141	switch (arg->op.op[1]) {
2143	case 0:	2142	case 0:
2144	val = left > right;	2143	val = left > right;
2145	break;	2144	break;
2146	case '>':	2145	case '>':
2147	val = left >> right;	2146	val = left >> right;
2148	break;	2147	break;
2149	case '=':	2148	case '=':
2150	val = left >= right;	2149	val = left >= right;
2151	break;	2150	break;
2152	default:	2151	default:
2153	die("unknown op '%s'", arg->op.op);	2152	die("unknown op '%s'", arg->op.op);
2154	}	2153	}
2155	break;	2154	break;
2156	case '=':	2155	case '=':
2157	if (arg->op.op[1] != '=')	2156	if (arg->op.op[1] != '=')
2158	die("unknown op '%s'", arg->op.op);	2157	die("unknown op '%s'", arg->op.op);
2159	val = left == right;	2158	val = left == right;
2160	break;	2159	break;
2161	case '-':	2160	case '-':
2162	val = left - right;	2161	val = left - right;
2163	break;	2162	break;
2164	case '+':	2163	case '+':
2165	val = left + right;	2164	val = left + right;
2166	break;	2165	break;
2167	default:	2166	default:
2168	die("unknown op '%s'", arg->op.op);	2167	die("unknown op '%s'", arg->op.op);
2169	}	2168	}
2170	break;	2169	break;
2171	default: /* not sure what to do there */	2170	default: /* not sure what to do there */
2172	return 0;	2171	return 0;
2173	}	2172	}
2174	return val;	2173	return val;
2175	}	2174	}
2176		2175
2177	struct flag {	2176	struct flag {
2178	const char *name;	2177	const char *name;
2179	unsigned long long value;	2178	unsigned long long value;
2180	};	2179	};
2181		2180
2182	static const struct flag flags[] = {	2181	static const struct flag flags[] = {
2183	{ "HI_SOFTIRQ", 0 },	2182	{ "HI_SOFTIRQ", 0 },
2184	{ "TIMER_SOFTIRQ", 1 },	2183	{ "TIMER_SOFTIRQ", 1 },
2185	{ "NET_TX_SOFTIRQ", 2 },	2184	{ "NET_TX_SOFTIRQ", 2 },
2186	{ "NET_RX_SOFTIRQ", 3 },	2185	{ "NET_RX_SOFTIRQ", 3 },
2187	{ "BLOCK_SOFTIRQ", 4 },	2186	{ "BLOCK_SOFTIRQ", 4 },
2188	{ "BLOCK_IOPOLL_SOFTIRQ", 5 },	2187	{ "BLOCK_IOPOLL_SOFTIRQ", 5 },
2189	{ "TASKLET_SOFTIRQ", 6 },	2188	{ "TASKLET_SOFTIRQ", 6 },
2190	{ "SCHED_SOFTIRQ", 7 },	2189	{ "SCHED_SOFTIRQ", 7 },
2191	{ "HRTIMER_SOFTIRQ", 8 },	2190	{ "HRTIMER_SOFTIRQ", 8 },
2192	{ "RCU_SOFTIRQ", 9 },	2191	{ "RCU_SOFTIRQ", 9 },
2193		2192
2194	{ "HRTIMER_NORESTART", 0 },	2193	{ "HRTIMER_NORESTART", 0 },
2195	{ "HRTIMER_RESTART", 1 },	2194	{ "HRTIMER_RESTART", 1 },
2196	};	2195	};
2197		2196
2198	unsigned long long eval_flag(const char *flag)	2197	unsigned long long eval_flag(const char *flag)
2199	{	2198	{
2200	int i;	2199	int i;
2201		2200
2202	/*	2201	/*
2203	* Some flags in the format files do not get converted.	2202	* Some flags in the format files do not get converted.
2204	* If the flag is not numeric, see if it is something that	2203	* If the flag is not numeric, see if it is something that
2205	* we already know about.	2204	* we already know about.
2206	*/	2205	*/
2207	if (isdigit(flag[0]))	2206	if (isdigit(flag[0]))
2208	return strtoull(flag, NULL, 0);	2207	return strtoull(flag, NULL, 0);
2209		2208
2210	for (i = 0; i < (int)(sizeof(flags)/sizeof(flags[0])); i++)	2209	for (i = 0; i < (int)(sizeof(flags)/sizeof(flags[0])); i++)
2211	if (strcmp(flags[i].name, flag) == 0)	2210	if (strcmp(flags[i].name, flag) == 0)
2212	return flags[i].value;	2211	return flags[i].value;
2213		2212
2214	return 0;	2213	return 0;
2215	}	2214	}
2216		2215
2217	static void print_str_arg(void *data, int size,	2216	static void print_str_arg(void *data, int size,
2218	struct event event, struct print_arg arg)	2217	struct event event, struct print_arg arg)
2219	{	2218	{
2220	struct print_flag_sym *flag;	2219	struct print_flag_sym *flag;
2221	unsigned long long val, fval;	2220	unsigned long long val, fval;
2222	char *str;	2221	char *str;
2223	int print;	2222	int print;
2224		2223
2225	switch (arg->type) {	2224	switch (arg->type) {
2226	case PRINT_NULL:	2225	case PRINT_NULL:
2227	/* ?? */	2226	/* ?? */
2228	return;	2227	return;
2229	case PRINT_ATOM:	2228	case PRINT_ATOM:
2230	printf("%s", arg->atom.atom);	2229	printf("%s", arg->atom.atom);
2231	return;	2230	return;
2232	case PRINT_FIELD:	2231	case PRINT_FIELD:
2233	if (!arg->field.field) {	2232	if (!arg->field.field) {
2234	arg->field.field = find_any_field(event, arg->field.name);	2233	arg->field.field = find_any_field(event, arg->field.name);
2235	if (!arg->field.field)	2234	if (!arg->field.field)
2236	die("field %s not found", arg->field.name);	2235	die("field %s not found", arg->field.name);
2237	}	2236	}
2238	str = malloc_or_die(arg->field.field->size + 1);	2237	str = malloc_or_die(arg->field.field->size + 1);
2239	memcpy(str, data + arg->field.field->offset,	2238	memcpy(str, data + arg->field.field->offset,
2240	arg->field.field->size);	2239	arg->field.field->size);
2241	str[arg->field.field->size] = 0;	2240	str[arg->field.field->size] = 0;
2242	printf("%s", str);	2241	printf("%s", str);
2243	free(str);	2242	free(str);
2244	break;	2243	break;
2245	case PRINT_FLAGS:	2244	case PRINT_FLAGS:
2246	val = eval_num_arg(data, size, event, arg->flags.field);	2245	val = eval_num_arg(data, size, event, arg->flags.field);
2247	print = 0;	2246	print = 0;
2248	for (flag = arg->flags.flags; flag; flag = flag->next) {	2247	for (flag = arg->flags.flags; flag; flag = flag->next) {
2249	fval = eval_flag(flag->value);	2248	fval = eval_flag(flag->value);
2250	if (!val && !fval) {	2249	if (!val && !fval) {
2251	printf("%s", flag->str);	2250	printf("%s", flag->str);
2252	break;	2251	break;
2253	}	2252	}
2254	if (fval && (val & fval) == fval) {	2253	if (fval && (val & fval) == fval) {
2255	if (print && arg->flags.delim)	2254	if (print && arg->flags.delim)
2256	printf("%s", arg->flags.delim);	2255	printf("%s", arg->flags.delim);
2257	printf("%s", flag->str);	2256	printf("%s", flag->str);
2258	print = 1;	2257	print = 1;
2259	val &= ~fval;	2258	val &= ~fval;
2260	}	2259	}
2261	}	2260	}
2262	break;	2261	break;
2263	case PRINT_SYMBOL:	2262	case PRINT_SYMBOL:
2264	val = eval_num_arg(data, size, event, arg->symbol.field);	2263	val = eval_num_arg(data, size, event, arg->symbol.field);
2265	for (flag = arg->symbol.symbols; flag; flag = flag->next) {	2264	for (flag = arg->symbol.symbols; flag; flag = flag->next) {
2266	fval = eval_flag(flag->value);	2265	fval = eval_flag(flag->value);
2267	if (val == fval) {	2266	if (val == fval) {
2268	printf("%s", flag->str);	2267	printf("%s", flag->str);
2269	break;	2268	break;
2270	}	2269	}
2271	}	2270	}
2272	break;	2271	break;
2273		2272
2274	case PRINT_TYPE:	2273	case PRINT_TYPE:
2275	break;	2274	break;
2276	case PRINT_STRING: {	2275	case PRINT_STRING: {
2277	int str_offset;	2276	int str_offset;
2278		2277
2279	if (arg->string.offset == -1) {	2278	if (arg->string.offset == -1) {
2280	struct format_field *f;	2279	struct format_field *f;
2281		2280
2282	f = find_any_field(event, arg->string.string);	2281	f = find_any_field(event, arg->string.string);
2283	arg->string.offset = f->offset;	2282	arg->string.offset = f->offset;
2284	}	2283	}
2285	str_offset = (int )(data + arg->string.offset);	2284	str_offset = (int )(data + arg->string.offset);
2286	str_offset &= 0xffff;	2285	str_offset &= 0xffff;
2287	printf("%s", ((char *)data) + str_offset);	2286	printf("%s", ((char *)data) + str_offset);
2288	break;	2287	break;
2289	}	2288	}
2290	case PRINT_OP:	2289	case PRINT_OP:
2291	/*	2290	/*
2292	* The only op for string should be ? :	2291	* The only op for string should be ? :
2293	*/	2292	*/
2294	if (arg->op.op[0] != '?')	2293	if (arg->op.op[0] != '?')
2295	return;	2294	return;
2296	val = eval_num_arg(data, size, event, arg->op.left);	2295	val = eval_num_arg(data, size, event, arg->op.left);
2297	if (val)	2296	if (val)
2298	print_str_arg(data, size, event, arg->op.right->op.left);	2297	print_str_arg(data, size, event, arg->op.right->op.left);
2299	else	2298	else
2300	print_str_arg(data, size, event, arg->op.right->op.right);	2299	print_str_arg(data, size, event, arg->op.right->op.right);
2301	break;	2300	break;
2302	default:	2301	default:
2303	/* well... */	2302	/* well... */
2304	break;	2303	break;
2305	}	2304	}
2306	}	2305	}
2307		2306
2308	static struct print_arg make_bprint_args(char fmt, void data, int size, struct event event)	2307	static struct print_arg make_bprint_args(char fmt, void data, int size, struct event event)
2309	{	2308	{
2310	static struct format_field field, ip_field;	2309	static struct format_field field, ip_field;
2311	struct print_arg args, arg, **next;	2310	struct print_arg args, arg, **next;
2312	unsigned long long ip, val;	2311	unsigned long long ip, val;
2313	char *ptr;	2312	char *ptr;
2314	void *bptr;	2313	void *bptr;
2315		2314
2316	if (!field) {	2315	if (!field) {
2317	field = find_field(event, "buf");	2316	field = find_field(event, "buf");
2318	if (!field)	2317	if (!field)
2319	die("can't find buffer field for binary printk");	2318	die("can't find buffer field for binary printk");
2320	ip_field = find_field(event, "ip");	2319	ip_field = find_field(event, "ip");
2321	if (!ip_field)	2320	if (!ip_field)
2322	die("can't find ip field for binary printk");	2321	die("can't find ip field for binary printk");
2323	}	2322	}
2324		2323
2325	ip = read_size(data + ip_field->offset, ip_field->size);	2324	ip = read_size(data + ip_field->offset, ip_field->size);
2326		2325
2327	/*	2326	/*
2328	* The first arg is the IP pointer.	2327	* The first arg is the IP pointer.
2329	*/	2328	*/
2330	args = malloc_or_die(sizeof(*args));	2329	args = malloc_or_die(sizeof(*args));
2331	arg = args;	2330	arg = args;
2332	arg->next = NULL;	2331	arg->next = NULL;
2333	next = &arg->next;	2332	next = &arg->next;
2334		2333
2335	arg->type = PRINT_ATOM;	2334	arg->type = PRINT_ATOM;
2336	arg->atom.atom = malloc_or_die(32);	2335	arg->atom.atom = malloc_or_die(32);
2337	sprintf(arg->atom.atom, "%lld", ip);	2336	sprintf(arg->atom.atom, "%lld", ip);
2338		2337
2339	/* skip the first "%pf : " */	2338	/* skip the first "%pf : " */
2340	for (ptr = fmt + 6, bptr = data + field->offset;	2339	for (ptr = fmt + 6, bptr = data + field->offset;
2341	bptr < data + size && *ptr; ptr++) {	2340	bptr < data + size && *ptr; ptr++) {
2342	int ls = 0;	2341	int ls = 0;
2343		2342
2344	if (*ptr == '%') {	2343	if (*ptr == '%') {
2345	process_again:	2344	process_again:
2346	ptr++;	2345	ptr++;
2347	switch (*ptr) {	2346	switch (*ptr) {
2348	case '%':	2347	case '%':
2349	break;	2348	break;
2350	case 'l':	2349	case 'l':
2351	ls++;	2350	ls++;
2352	goto process_again;	2351	goto process_again;
2353	case 'L':	2352	case 'L':
2354	ls = 2;	2353	ls = 2;
2355	goto process_again;	2354	goto process_again;
2356	case '0' ... '9':	2355	case '0' ... '9':
2357	goto process_again;	2356	goto process_again;
2358	case 'p':	2357	case 'p':
2359	ls = 1;	2358	ls = 1;
2360	/* fall through */	2359	/* fall through */
2361	case 'd':	2360	case 'd':
2362	case 'u':	2361	case 'u':
2363	case 'x':	2362	case 'x':
2364	case 'i':	2363	case 'i':
2365	/* the pointers are always 4 bytes aligned */	2364	/* the pointers are always 4 bytes aligned */
2366	bptr = (void *)(((unsigned long)bptr + 3) &	2365	bptr = (void *)(((unsigned long)bptr + 3) &
2367	~3);	2366	~3);
2368	switch (ls) {	2367	switch (ls) {
2369	case 0:	2368	case 0:
2370	case 1:	2369	case 1:
2371	ls = long_size;	2370	ls = long_size;
2372	break;	2371	break;
2373	case 2:	2372	case 2:
2374	ls = 8;	2373	ls = 8;
2375	default:	2374	default:
2376	break;	2375	break;
2377	}	2376	}
2378	val = read_size(bptr, ls);	2377	val = read_size(bptr, ls);
2379	bptr += ls;	2378	bptr += ls;
2380	arg = malloc_or_die(sizeof(*arg));	2379	arg = malloc_or_die(sizeof(*arg));
2381	arg->next = NULL;	2380	arg->next = NULL;
2382	arg->type = PRINT_ATOM;	2381	arg->type = PRINT_ATOM;
2383	arg->atom.atom = malloc_or_die(32);	2382	arg->atom.atom = malloc_or_die(32);
2384	sprintf(arg->atom.atom, "%lld", val);	2383	sprintf(arg->atom.atom, "%lld", val);
2385	*next = arg;	2384	*next = arg;
2386	next = &arg->next;	2385	next = &arg->next;
2387	break;	2386	break;
2388	case 's':	2387	case 's':
2389	arg = malloc_or_die(sizeof(*arg));	2388	arg = malloc_or_die(sizeof(*arg));
2390	arg->next = NULL;	2389	arg->next = NULL;
2391	arg->type = PRINT_STRING;	2390	arg->type = PRINT_STRING;
2392	arg->string.string = strdup(bptr);	2391	arg->string.string = strdup(bptr);
2393	bptr += strlen(bptr) + 1;	2392	bptr += strlen(bptr) + 1;
2394	*next = arg;	2393	*next = arg;
2395	next = &arg->next;	2394	next = &arg->next;
2396	default:	2395	default:
2397	break;	2396	break;
2398	}	2397	}
2399	}	2398	}
2400	}	2399	}
2401		2400
2402	return args;	2401	return args;
2403	}	2402	}
2404		2403
2405	static void free_args(struct print_arg *args)	2404	static void free_args(struct print_arg *args)
2406	{	2405	{
2407	struct print_arg *next;	2406	struct print_arg *next;
2408		2407
2409	while (args) {	2408	while (args) {
2410	next = args->next;	2409	next = args->next;
2411		2410
2412	if (args->type == PRINT_ATOM)	2411	if (args->type == PRINT_ATOM)
2413	free(args->atom.atom);	2412	free(args->atom.atom);
2414	else	2413	else
2415	free(args->string.string);	2414	free(args->string.string);
2416	free(args);	2415	free(args);
2417	args = next;	2416	args = next;
2418	}	2417	}
2419	}	2418	}
2420		2419
2421	static char get_bprint_format(void data, int size __unused, struct event *event)	2420	static char get_bprint_format(void data, int size __unused, struct event *event)
2422	{	2421	{
2423	unsigned long long addr;	2422	unsigned long long addr;
2424	static struct format_field *field;	2423	static struct format_field *field;
2425	struct printk_map *printk;	2424	struct printk_map *printk;
2426	char *format;	2425	char *format;
2427	char *p;	2426	char *p;
2428		2427
2429	if (!field) {	2428	if (!field) {
2430	field = find_field(event, "fmt");	2429	field = find_field(event, "fmt");
2431	if (!field)	2430	if (!field)
2432	die("can't find format field for binary printk");	2431	die("can't find format field for binary printk");
2433	printf("field->offset = %d size=%d\n", field->offset, field->size);	2432	printf("field->offset = %d size=%d\n", field->offset, field->size);
2434	}	2433	}
2435		2434
2436	addr = read_size(data + field->offset, field->size);	2435	addr = read_size(data + field->offset, field->size);
2437		2436
2438	printk = find_printk(addr);	2437	printk = find_printk(addr);
2439	if (!printk) {	2438	if (!printk) {
2440	format = malloc_or_die(45);	2439	format = malloc_or_die(45);
2441	sprintf(format, "%%pf : (NO FORMAT FOUND at %llx)\n",	2440	sprintf(format, "%%pf : (NO FORMAT FOUND at %llx)\n",
2442	addr);	2441	addr);
2443	return format;	2442	return format;
2444	}	2443	}
2445		2444
2446	p = printk->printk;	2445	p = printk->printk;
2447	/* Remove any quotes. */	2446	/* Remove any quotes. */
2448	if (*p == '"')	2447	if (*p == '"')
2449	p++;	2448	p++;
2450	format = malloc_or_die(strlen(p) + 10);	2449	format = malloc_or_die(strlen(p) + 10);
2451	sprintf(format, "%s : %s", "%pf", p);	2450	sprintf(format, "%s : %s", "%pf", p);
2452	/* remove ending quotes and new line since we will add one too */	2451	/* remove ending quotes and new line since we will add one too */
2453	p = format + strlen(format) - 1;	2452	p = format + strlen(format) - 1;
2454	if (*p == '"')	2453	if (*p == '"')
2455	*p = 0;	2454	*p = 0;
2456		2455
2457	p -= 2;	2456	p -= 2;
2458	if (strcmp(p, "\\n") == 0)	2457	if (strcmp(p, "\\n") == 0)
2459	*p = 0;	2458	*p = 0;
2460		2459
2461	return format;	2460	return format;
2462	}	2461	}
2463		2462
2464	static void pretty_print(void data, int size, struct event event)	2463	static void pretty_print(void data, int size, struct event event)
2465	{	2464	{
2466	struct print_fmt *print_fmt = &event->print_fmt;	2465	struct print_fmt *print_fmt = &event->print_fmt;
2467	struct print_arg *arg = print_fmt->args;	2466	struct print_arg *arg = print_fmt->args;
2468	struct print_arg *args = NULL;	2467	struct print_arg *args = NULL;
2469	const char *ptr = print_fmt->format;	2468	const char *ptr = print_fmt->format;
2470	unsigned long long val;	2469	unsigned long long val;
2471	struct func_map *func;	2470	struct func_map *func;
2472	const char *saveptr;	2471	const char *saveptr;
2473	char *bprint_fmt = NULL;	2472	char *bprint_fmt = NULL;
2474	char format[32];	2473	char format[32];
2475	int show_func;	2474	int show_func;
2476	int len;	2475	int len;
2477	int ls;	2476	int ls;
2478		2477
2479	if (event->flags & EVENT_FL_ISFUNC)	2478	if (event->flags & EVENT_FL_ISFUNC)
2480	ptr = " %pF <-- %pF";	2479	ptr = " %pF <-- %pF";
2481		2480
2482	if (event->flags & EVENT_FL_ISBPRINT) {	2481	if (event->flags & EVENT_FL_ISBPRINT) {
2483	bprint_fmt = get_bprint_format(data, size, event);	2482	bprint_fmt = get_bprint_format(data, size, event);
2484	args = make_bprint_args(bprint_fmt, data, size, event);	2483	args = make_bprint_args(bprint_fmt, data, size, event);
2485	arg = args;	2484	arg = args;
2486	ptr = bprint_fmt;	2485	ptr = bprint_fmt;
2487	}	2486	}
2488		2487
2489	for (; *ptr; ptr++) {	2488	for (; *ptr; ptr++) {
2490	ls = 0;	2489	ls = 0;
2491	if (*ptr == '\\') {	2490	if (*ptr == '\\') {
2492	ptr++;	2491	ptr++;
2493	switch (*ptr) {	2492	switch (*ptr) {
2494	case 'n':	2493	case 'n':
2495	printf("\n");	2494	printf("\n");
2496	break;	2495	break;
2497	case 't':	2496	case 't':
2498	printf("\t");	2497	printf("\t");
2499	break;	2498	break;
2500	case 'r':	2499	case 'r':
2501	printf("\r");	2500	printf("\r");
2502	break;	2501	break;
2503	case '\\':	2502	case '\\':
2504	printf("\\");	2503	printf("\\");
2505	break;	2504	break;
2506	default:	2505	default:
2507	printf("%c", *ptr);	2506	printf("%c", *ptr);
2508	break;	2507	break;
2509	}	2508	}
2510		2509
2511	} else if (*ptr == '%') {	2510	} else if (*ptr == '%') {
2512	saveptr = ptr;	2511	saveptr = ptr;
2513	show_func = 0;	2512	show_func = 0;
2514	cont_process:	2513	cont_process:
2515	ptr++;	2514	ptr++;
2516	switch (*ptr) {	2515	switch (*ptr) {
2517	case '%':	2516	case '%':
2518	printf("%%");	2517	printf("%%");
2519	break;	2518	break;
2520	case 'l':	2519	case 'l':
2521	ls++;	2520	ls++;
2522	goto cont_process;	2521	goto cont_process;
2523	case 'L':	2522	case 'L':
2524	ls = 2;	2523	ls = 2;
2525	goto cont_process;	2524	goto cont_process;
2526	case 'z':	2525	case 'z':
2527	case 'Z':	2526	case 'Z':
2528	case '0' ... '9':	2527	case '0' ... '9':
2529	goto cont_process;	2528	goto cont_process;
2530	case 'p':	2529	case 'p':
2531	if (long_size == 4)	2530	if (long_size == 4)
2532	ls = 1;	2531	ls = 1;
2533	else	2532	else
2534	ls = 2;	2533	ls = 2;
2535		2534
2536	if (*(ptr+1) == 'F' \|\|	2535	if (*(ptr+1) == 'F' \|\|
2537	*(ptr+1) == 'f') {	2536	*(ptr+1) == 'f') {
2538	ptr++;	2537	ptr++;
2539	show_func = *ptr;	2538	show_func = *ptr;
2540	}	2539	}
2541		2540
2542	/* fall through */	2541	/* fall through */
2543	case 'd':	2542	case 'd':
2544	case 'i':	2543	case 'i':
2545	case 'x':	2544	case 'x':
2546	case 'X':	2545	case 'X':
2547	case 'u':	2546	case 'u':
2548	if (!arg)	2547	if (!arg)
2549	die("no argument match");	2548	die("no argument match");
2550		2549
2551	len = ((unsigned long)ptr + 1) -	2550	len = ((unsigned long)ptr + 1) -
2552	(unsigned long)saveptr;	2551	(unsigned long)saveptr;
2553		2552
2554	/* should never happen */	2553	/* should never happen */
2555	if (len > 32)	2554	if (len > 32)
2556	die("bad format!");	2555	die("bad format!");
2557		2556
2558	memcpy(format, saveptr, len);	2557	memcpy(format, saveptr, len);
2559	format[len] = 0;	2558	format[len] = 0;
2560		2559
2561	val = eval_num_arg(data, size, event, arg);	2560	val = eval_num_arg(data, size, event, arg);
2562	arg = arg->next;	2561	arg = arg->next;
2563		2562
2564	if (show_func) {	2563	if (show_func) {
2565	func = find_func(val);	2564	func = find_func(val);
2566	if (func) {	2565	if (func) {
2567	printf("%s", func->func);	2566	printf("%s", func->func);
2568	if (show_func == 'F')	2567	if (show_func == 'F')
2569	printf("+0x%llx",	2568	printf("+0x%llx",
2570	val - func->addr);	2569	val - func->addr);
2571	break;	2570	break;
2572	}	2571	}
2573	}	2572	}
2574	switch (ls) {	2573	switch (ls) {
2575	case 0:	2574	case 0:
2576	printf(format, (int)val);	2575	printf(format, (int)val);
2577	break;	2576	break;
2578	case 1:	2577	case 1:
2579	printf(format, (long)val);	2578	printf(format, (long)val);
2580	break;	2579	break;
2581	case 2:	2580	case 2:
2582	printf(format, (long long)val);	2581	printf(format, (long long)val);
2583	break;	2582	break;
2584	default:	2583	default:
2585	die("bad count (%d)", ls);	2584	die("bad count (%d)", ls);
2586	}	2585	}
2587	break;	2586	break;
2588	case 's':	2587	case 's':
2589	if (!arg)	2588	if (!arg)
2590	die("no matching argument");	2589	die("no matching argument");
2591		2590
2592	print_str_arg(data, size, event, arg);	2591	print_str_arg(data, size, event, arg);
2593	arg = arg->next;	2592	arg = arg->next;
2594	break;	2593	break;
2595	default:	2594	default:
2596	printf(">%c<", *ptr);	2595	printf(">%c<", *ptr);
2597		2596
2598	}	2597	}
2599	} else	2598	} else
2600	printf("%c", *ptr);	2599	printf("%c", *ptr);
2601	}	2600	}
2602		2601
2603	if (args) {	2602	if (args) {
2604	free_args(args);	2603	free_args(args);
2605	free(bprint_fmt);	2604	free(bprint_fmt);
2606	}	2605	}
2607	}	2606	}
2608		2607
2609	static inline int log10_cpu(int nb)	2608	static inline int log10_cpu(int nb)
2610	{	2609	{
2611	if (nb / 100)	2610	if (nb / 100)
2612	return 3;	2611	return 3;
2613	if (nb / 10)	2612	if (nb / 10)
2614	return 2;	2613	return 2;
2615	return 1;	2614	return 1;
2616	}	2615	}
2617		2616
2618	static void print_lat_fmt(void *data, int size __unused)	2617	static void print_lat_fmt(void *data, int size __unused)
2619	{	2618	{
2620	unsigned int lat_flags;	2619	unsigned int lat_flags;
2621	unsigned int pc;	2620	unsigned int pc;
2622	int lock_depth;	2621	int lock_depth;
2623	int hardirq;	2622	int hardirq;
2624	int softirq;	2623	int softirq;
2625		2624
2626	lat_flags = parse_common_flags(data);	2625	lat_flags = parse_common_flags(data);
2627	pc = parse_common_pc(data);	2626	pc = parse_common_pc(data);
2628	lock_depth = parse_common_lock_depth(data);	2627	lock_depth = parse_common_lock_depth(data);
2629		2628
2630	hardirq = lat_flags & TRACE_FLAG_HARDIRQ;	2629	hardirq = lat_flags & TRACE_FLAG_HARDIRQ;
2631	softirq = lat_flags & TRACE_FLAG_SOFTIRQ;	2630	softirq = lat_flags & TRACE_FLAG_SOFTIRQ;
2632		2631
2633	printf("%c%c%c",	2632	printf("%c%c%c",
2634	(lat_flags & TRACE_FLAG_IRQS_OFF) ? 'd' :	2633	(lat_flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
2635	(lat_flags & TRACE_FLAG_IRQS_NOSUPPORT) ?	2634	(lat_flags & TRACE_FLAG_IRQS_NOSUPPORT) ?
2636	'X' : '.',	2635	'X' : '.',
2637	(lat_flags & TRACE_FLAG_NEED_RESCHED) ?	2636	(lat_flags & TRACE_FLAG_NEED_RESCHED) ?
2638	'N' : '.',	2637	'N' : '.',
2639	(hardirq && softirq) ? 'H' :	2638	(hardirq && softirq) ? 'H' :
2640	hardirq ? 'h' : softirq ? 's' : '.');	2639	hardirq ? 'h' : softirq ? 's' : '.');
2641		2640
2642	if (pc)	2641	if (pc)
2643	printf("%x", pc);	2642	printf("%x", pc);
2644	else	2643	else
2645	printf(".");	2644	printf(".");
2646		2645
2647	if (lock_depth < 0)	2646	if (lock_depth < 0)
2648	printf(". ");	2647	printf(". ");
2649	else	2648	else
2650	printf("%d ", lock_depth);	2649	printf("%d ", lock_depth);
2651	}	2650	}
2652		2651
2653	#define TRACE_GRAPH_INDENT 2	2652	#define TRACE_GRAPH_INDENT 2
2654		2653
2655	static struct record *	2654	static struct record *
2656	get_return_for_leaf(int cpu, int cur_pid, unsigned long long cur_func,	2655	get_return_for_leaf(int cpu, int cur_pid, unsigned long long cur_func,
2657	struct record *next)	2656	struct record *next)
2658	{	2657	{
2659	struct format_field *field;	2658	struct format_field *field;
2660	struct event *event;	2659	struct event *event;
2661	unsigned long val;	2660	unsigned long val;
2662	int type;	2661	int type;
2663	int pid;	2662	int pid;
2664		2663
2665	type = trace_parse_common_type(next->data);	2664	type = trace_parse_common_type(next->data);
2666	event = trace_find_event(type);	2665	event = trace_find_event(type);
2667	if (!event)	2666	if (!event)
2668	return NULL;	2667	return NULL;
2669		2668
2670	if (!(event->flags & EVENT_FL_ISFUNCRET))	2669	if (!(event->flags & EVENT_FL_ISFUNCRET))
2671	return NULL;	2670	return NULL;
2672		2671
2673	pid = trace_parse_common_pid(next->data);	2672	pid = trace_parse_common_pid(next->data);
2674	field = find_field(event, "func");	2673	field = find_field(event, "func");
2675	if (!field)	2674	if (!field)
2676	die("function return does not have field func");	2675	die("function return does not have field func");
2677		2676
2678	val = read_size(next->data + field->offset, field->size);	2677	val = read_size(next->data + field->offset, field->size);
2679		2678
2680	if (cur_pid != pid \|\| cur_func != val)	2679	if (cur_pid != pid \|\| cur_func != val)
2681	return NULL;	2680	return NULL;
2682		2681
2683	/* this is a leaf, now advance the iterator */	2682	/* this is a leaf, now advance the iterator */
2684	return trace_read_data(cpu);	2683	return trace_read_data(cpu);
2685	}	2684	}
2686		2685
2687	/* Signal a overhead of time execution to the output */	2686	/* Signal a overhead of time execution to the output */
2688	static void print_graph_overhead(unsigned long long duration)	2687	static void print_graph_overhead(unsigned long long duration)
2689	{	2688	{
2690	/* Non nested entry or return */	2689	/* Non nested entry or return */
2691	if (duration == ~0ULL)	2690	if (duration == ~0ULL)
2692	return (void)printf(" ");	2691	return (void)printf(" ");
2693		2692
2694	/* Duration exceeded 100 msecs */	2693	/* Duration exceeded 100 msecs */
2695	if (duration > 100000ULL)	2694	if (duration > 100000ULL)
2696	return (void)printf("! ");	2695	return (void)printf("! ");
2697		2696
2698	/* Duration exceeded 10 msecs */	2697	/* Duration exceeded 10 msecs */
2699	if (duration > 10000ULL)	2698	if (duration > 10000ULL)
2700	return (void)printf("+ ");	2699	return (void)printf("+ ");
2701		2700
2702	printf(" ");	2701	printf(" ");
2703	}	2702	}
2704		2703
2705	static void print_graph_duration(unsigned long long duration)	2704	static void print_graph_duration(unsigned long long duration)
2706	{	2705	{
2707	unsigned long usecs = duration / 1000;	2706	unsigned long usecs = duration / 1000;
2708	unsigned long nsecs_rem = duration % 1000;	2707	unsigned long nsecs_rem = duration % 1000;
2709	/* log10(ULONG_MAX) + '\0' */	2708	/* log10(ULONG_MAX) + '\0' */
2710	char msecs_str[21];	2709	char msecs_str[21];
2711	char nsecs_str[5];	2710	char nsecs_str[5];
2712	int len;	2711	int len;
2713	int i;	2712	int i;
2714		2713
2715	sprintf(msecs_str, "%lu", usecs);	2714	sprintf(msecs_str, "%lu", usecs);
2716		2715
2717	/* Print msecs */	2716	/* Print msecs */
2718	len = printf("%lu", usecs);	2717	len = printf("%lu", usecs);
2719		2718
2720	/* Print nsecs (we don't want to exceed 7 numbers) */	2719	/* Print nsecs (we don't want to exceed 7 numbers) */
2721	if (len < 7) {	2720	if (len < 7) {
2722	snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem);	2721	snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem);
2723	len += printf(".%s", nsecs_str);	2722	len += printf(".%s", nsecs_str);
2724	}	2723	}
2725		2724
2726	printf(" us ");	2725	printf(" us ");
2727		2726
2728	/* Print remaining spaces to fit the row's width */	2727	/* Print remaining spaces to fit the row's width */
2729	for (i = len; i < 7; i++)	2728	for (i = len; i < 7; i++)
2730	printf(" ");	2729	printf(" ");
2731		2730
2732	printf("\| ");	2731	printf("\| ");
2733	}	2732	}
2734		2733
2735	static void	2734	static void
2736	print_graph_entry_leaf(struct event event, void data, struct record *ret_rec)	2735	print_graph_entry_leaf(struct event event, void data, struct record *ret_rec)
2737	{	2736	{
2738	unsigned long long rettime, calltime;	2737	unsigned long long rettime, calltime;
2739	unsigned long long duration, depth;	2738	unsigned long long duration, depth;
2740	unsigned long long val;	2739	unsigned long long val;
2741	struct format_field *field;	2740	struct format_field *field;
2742	struct func_map *func;	2741	struct func_map *func;
2743	struct event *ret_event;	2742	struct event *ret_event;
2744	int type;	2743	int type;
2745	int i;	2744	int i;
2746		2745
2747	type = trace_parse_common_type(ret_rec->data);	2746	type = trace_parse_common_type(ret_rec->data);
2748	ret_event = trace_find_event(type);	2747	ret_event = trace_find_event(type);
2749		2748
2750	field = find_field(ret_event, "rettime");	2749	field = find_field(ret_event, "rettime");
2751	if (!field)	2750	if (!field)
2752	die("can't find rettime in return graph");	2751	die("can't find rettime in return graph");
2753	rettime = read_size(ret_rec->data + field->offset, field->size);	2752	rettime = read_size(ret_rec->data + field->offset, field->size);
2754		2753
2755	field = find_field(ret_event, "calltime");	2754	field = find_field(ret_event, "calltime");
2756	if (!field)	2755	if (!field)
2757	die("can't find rettime in return graph");	2756	die("can't find rettime in return graph");
2758	calltime = read_size(ret_rec->data + field->offset, field->size);	2757	calltime = read_size(ret_rec->data + field->offset, field->size);
2759		2758
2760	duration = rettime - calltime;	2759	duration = rettime - calltime;
2761		2760
2762	/* Overhead */	2761	/* Overhead */
2763	print_graph_overhead(duration);	2762	print_graph_overhead(duration);
2764		2763
2765	/* Duration */	2764	/* Duration */
2766	print_graph_duration(duration);	2765	print_graph_duration(duration);
2767		2766
2768	field = find_field(event, "depth");	2767	field = find_field(event, "depth");
2769	if (!field)	2768	if (!field)
2770	die("can't find depth in entry graph");	2769	die("can't find depth in entry graph");
2771	depth = read_size(data + field->offset, field->size);	2770	depth = read_size(data + field->offset, field->size);
2772		2771
2773	/* Function */	2772	/* Function */
2774	for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++)	2773	for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++)
2775	printf(" ");	2774	printf(" ");
2776		2775
2777	field = find_field(event, "func");	2776	field = find_field(event, "func");
2778	if (!field)	2777	if (!field)
2779	die("can't find func in entry graph");	2778	die("can't find func in entry graph");
2780	val = read_size(data + field->offset, field->size);	2779	val = read_size(data + field->offset, field->size);
2781	func = find_func(val);	2780	func = find_func(val);
2782		2781
2783	if (func)	2782	if (func)
2784	printf("%s();", func->func);	2783	printf("%s();", func->func);
2785	else	2784	else
2786	printf("%llx();", val);	2785	printf("%llx();", val);
2787	}	2786	}
2788		2787
2789	static void print_graph_nested(struct event event, void data)	2788	static void print_graph_nested(struct event event, void data)
2790	{	2789	{
2791	struct format_field *field;	2790	struct format_field *field;
2792	unsigned long long depth;	2791	unsigned long long depth;
2793	unsigned long long val;	2792	unsigned long long val;
2794	struct func_map *func;	2793	struct func_map *func;
2795	int i;	2794	int i;
2796		2795
2797	/* No overhead */	2796	/* No overhead */
2798	print_graph_overhead(-1);	2797	print_graph_overhead(-1);
2799		2798
2800	/* No time */	2799	/* No time */
2801	printf(" \| ");	2800	printf(" \| ");
2802		2801
2803	field = find_field(event, "depth");	2802	field = find_field(event, "depth");
2804	if (!field)	2803	if (!field)
2805	die("can't find depth in entry graph");	2804	die("can't find depth in entry graph");
2806	depth = read_size(data + field->offset, field->size);	2805	depth = read_size(data + field->offset, field->size);
2807		2806
2808	/* Function */	2807	/* Function */
2809	for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++)	2808	for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++)
2810	printf(" ");	2809	printf(" ");
2811		2810
2812	field = find_field(event, "func");	2811	field = find_field(event, "func");
2813	if (!field)	2812	if (!field)
2814	die("can't find func in entry graph");	2813	die("can't find func in entry graph");
2815	val = read_size(data + field->offset, field->size);	2814	val = read_size(data + field->offset, field->size);
2816	func = find_func(val);	2815	func = find_func(val);
2817		2816
2818	if (func)	2817	if (func)
2819	printf("%s() {", func->func);	2818	printf("%s() {", func->func);
2820	else	2819	else
2821	printf("%llx() {", val);	2820	printf("%llx() {", val);
2822	}	2821	}
2823		2822
2824	static void	2823	static void
2825	pretty_print_func_ent(void data, int size, struct event event,	2824	pretty_print_func_ent(void data, int size, struct event event,
2826	int cpu, int pid)	2825	int cpu, int pid)
2827	{	2826	{
2828	struct format_field *field;	2827	struct format_field *field;
2829	struct record *rec;	2828	struct record *rec;
2830	void *copy_data;	2829	void *copy_data;
2831	unsigned long val;	2830	unsigned long val;
2832		2831
2833	if (latency_format) {	2832	if (latency_format) {
2834	print_lat_fmt(data, size);	2833	print_lat_fmt(data, size);
2835	printf(" \| ");	2834	printf(" \| ");
2836	}	2835	}
2837		2836
2838	field = find_field(event, "func");	2837	field = find_field(event, "func");
2839	if (!field)	2838	if (!field)
2840	die("function entry does not have func field");	2839	die("function entry does not have func field");
2841		2840
2842	val = read_size(data + field->offset, field->size);	2841	val = read_size(data + field->offset, field->size);
2843		2842
2844	/*	2843	/*
2845	* peek_data may unmap the data pointer. Copy it first.	2844	* peek_data may unmap the data pointer. Copy it first.
2846	*/	2845	*/
2847	copy_data = malloc_or_die(size);	2846	copy_data = malloc_or_die(size);
2848	memcpy(copy_data, data, size);	2847	memcpy(copy_data, data, size);
2849	data = copy_data;	2848	data = copy_data;
2850		2849
2851	rec = trace_peek_data(cpu);	2850	rec = trace_peek_data(cpu);
2852	if (rec) {	2851	if (rec) {
2853	rec = get_return_for_leaf(cpu, pid, val, rec);	2852	rec = get_return_for_leaf(cpu, pid, val, rec);
2854	if (rec) {	2853	if (rec) {
2855	print_graph_entry_leaf(event, data, rec);	2854	print_graph_entry_leaf(event, data, rec);
2856	goto out_free;	2855	goto out_free;
2857	}	2856	}
2858	}	2857	}
2859	print_graph_nested(event, data);	2858	print_graph_nested(event, data);
2860	out_free:	2859	out_free:
2861	free(data);	2860	free(data);
2862	}	2861	}
2863		2862
2864	static void	2863	static void
2865	pretty_print_func_ret(void data, int size __unused, struct event event)	2864	pretty_print_func_ret(void data, int size __unused, struct event event)
2866	{	2865	{
2867	unsigned long long rettime, calltime;	2866	unsigned long long rettime, calltime;
2868	unsigned long long duration, depth;	2867	unsigned long long duration, depth;
2869	struct format_field *field;	2868	struct format_field *field;
2870	int i;	2869	int i;
2871		2870
2872	if (latency_format) {	2871	if (latency_format) {
2873	print_lat_fmt(data, size);	2872	print_lat_fmt(data, size);
2874	printf(" \| ");	2873	printf(" \| ");
2875	}	2874	}
2876		2875
2877	field = find_field(event, "rettime");	2876	field = find_field(event, "rettime");
2878	if (!field)	2877	if (!field)
2879	die("can't find rettime in return graph");	2878	die("can't find rettime in return graph");
2880	rettime = read_size(data + field->offset, field->size);	2879	rettime = read_size(data + field->offset, field->size);
2881		2880
2882	field = find_field(event, "calltime");	2881	field = find_field(event, "calltime");
2883	if (!field)	2882	if (!field)
2884	die("can't find calltime in return graph");	2883	die("can't find calltime in return graph");
2885	calltime = read_size(data + field->offset, field->size);	2884	calltime = read_size(data + field->offset, field->size);
2886		2885
2887	duration = rettime - calltime;	2886	duration = rettime - calltime;
2888		2887
2889	/* Overhead */	2888	/* Overhead */
2890	print_graph_overhead(duration);	2889	print_graph_overhead(duration);
2891		2890
2892	/* Duration */	2891	/* Duration */
2893	print_graph_duration(duration);	2892	print_graph_duration(duration);
2894		2893
2895	field = find_field(event, "depth");	2894	field = find_field(event, "depth");
2896	if (!field)	2895	if (!field)
2897	die("can't find depth in entry graph");	2896	die("can't find depth in entry graph");
2898	depth = read_size(data + field->offset, field->size);	2897	depth = read_size(data + field->offset, field->size);
2899		2898
2900	/* Function */	2899	/* Function */
2901	for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++)	2900	for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++)
2902	printf(" ");	2901	printf(" ");
2903		2902
2904	printf("}");	2903	printf("}");
2905	}	2904	}
2906		2905
2907	static void	2906	static void
2908	pretty_print_func_graph(void data, int size, struct event event,	2907	pretty_print_func_graph(void data, int size, struct event event,
2909	int cpu, int pid)	2908	int cpu, int pid)
2910	{	2909	{
2911	if (event->flags & EVENT_FL_ISFUNCENT)	2910	if (event->flags & EVENT_FL_ISFUNCENT)
2912	pretty_print_func_ent(data, size, event, cpu, pid);	2911	pretty_print_func_ent(data, size, event, cpu, pid);
2913	else if (event->flags & EVENT_FL_ISFUNCRET)	2912	else if (event->flags & EVENT_FL_ISFUNCRET)
2914	pretty_print_func_ret(data, size, event);	2913	pretty_print_func_ret(data, size, event);
2915	printf("\n");	2914	printf("\n");
2916	}	2915	}
2917		2916
2918	void print_trace_event(int cpu, void *data, int size)	2917	void print_trace_event(int cpu, void *data, int size)
2919	{	2918	{
2920	struct event *event;	2919	struct event *event;
2921	int type;	2920	int type;
2922	int pid;	2921	int pid;
2923		2922
2924	type = trace_parse_common_type(data);	2923	type = trace_parse_common_type(data);
2925		2924
2926	event = trace_find_event(type);	2925	event = trace_find_event(type);
2927	if (!event) {	2926	if (!event) {
2928	warning("ug! no event found for type %d", type);	2927	warning("ug! no event found for type %d", type);
2929	return;	2928	return;
2930	}	2929	}
2931		2930
2932	pid = trace_parse_common_pid(data);	2931	pid = trace_parse_common_pid(data);
2933		2932
2934	if (event->flags & (EVENT_FL_ISFUNCENT \| EVENT_FL_ISFUNCRET))	2933	if (event->flags & (EVENT_FL_ISFUNCENT \| EVENT_FL_ISFUNCRET))
2935	return pretty_print_func_graph(data, size, event, cpu, pid);	2934	return pretty_print_func_graph(data, size, event, cpu, pid);
2936		2935
2937	if (latency_format)	2936	if (latency_format)
2938	print_lat_fmt(data, size);	2937	print_lat_fmt(data, size);
2939		2938
2940	if (event->flags & EVENT_FL_FAILED) {	2939	if (event->flags & EVENT_FL_FAILED) {
2941	printf("EVENT '%s' FAILED TO PARSE\n",	2940	printf("EVENT '%s' FAILED TO PARSE\n",
2942	event->name);	2941	event->name);
2943	return;	2942	return;
2944	}	2943	}
2945		2944
2946	pretty_print(data, size, event);	2945	pretty_print(data, size, event);
2947	}	2946	}
2948		2947
2949	static void print_fields(struct print_flag_sym *field)	2948	static void print_fields(struct print_flag_sym *field)
2950	{	2949	{
2951	printf("{ %s, %s }", field->value, field->str);	2950	printf("{ %s, %s }", field->value, field->str);
2952	if (field->next) {	2951	if (field->next) {
2953	printf(", ");	2952	printf(", ");
2954	print_fields(field->next);	2953	print_fields(field->next);
2955	}	2954	}
2956	}	2955	}
2957		2956
2958	static void print_args(struct print_arg *args)	2957	static void print_args(struct print_arg *args)
2959	{	2958	{
2960	int print_paren = 1;	2959	int print_paren = 1;
2961		2960
2962	switch (args->type) {	2961	switch (args->type) {
2963	case PRINT_NULL:	2962	case PRINT_NULL:
2964	printf("null");	2963	printf("null");
2965	break;	2964	break;
2966	case PRINT_ATOM:	2965	case PRINT_ATOM:
2967	printf("%s", args->atom.atom);	2966	printf("%s", args->atom.atom);
2968	break;	2967	break;
2969	case PRINT_FIELD:	2968	case PRINT_FIELD:
2970	printf("REC->%s", args->field.name);	2969	printf("REC->%s", args->field.name);
2971	break;	2970	break;
2972	case PRINT_FLAGS:	2971	case PRINT_FLAGS:
2973	printf("__print_flags(");	2972	printf("__print_flags(");
2974	print_args(args->flags.field);	2973	print_args(args->flags.field);
2975	printf(", %s, ", args->flags.delim);	2974	printf(", %s, ", args->flags.delim);
2976	print_fields(args->flags.flags);	2975	print_fields(args->flags.flags);
2977	printf(")");	2976	printf(")");
2978	break;	2977	break;
2979	case PRINT_SYMBOL:	2978	case PRINT_SYMBOL:
2980	printf("__print_symbolic(");	2979	printf("__print_symbolic(");
2981	print_args(args->symbol.field);	2980	print_args(args->symbol.field);
2982	printf(", ");	2981	printf(", ");
2983	print_fields(args->symbol.symbols);	2982	print_fields(args->symbol.symbols);
2984	printf(")");	2983	printf(")");
2985	break;	2984	break;
2986	case PRINT_STRING:	2985	case PRINT_STRING:
2987	printf("__get_str(%s)", args->string.string);	2986	printf("__get_str(%s)", args->string.string);
2988	break;	2987	break;
2989	case PRINT_TYPE:	2988	case PRINT_TYPE:
2990	printf("(%s)", args->typecast.type);	2989	printf("(%s)", args->typecast.type);
2991	print_args(args->typecast.item);	2990	print_args(args->typecast.item);
2992	break;	2991	break;
2993	case PRINT_OP:	2992	case PRINT_OP:
2994	if (strcmp(args->op.op, ":") == 0)	2993	if (strcmp(args->op.op, ":") == 0)
2995	print_paren = 0;	2994	print_paren = 0;
2996	if (print_paren)	2995	if (print_paren)
2997	printf("(");	2996	printf("(");
2998	print_args(args->op.left);	2997	print_args(args->op.left);
2999	printf(" %s ", args->op.op);	2998	printf(" %s ", args->op.op);
3000	print_args(args->op.right);	2999	print_args(args->op.right);
3001	if (print_paren)	3000	if (print_paren)
3002	printf(")");	3001	printf(")");
3003	break;	3002	break;
3004	default:	3003	default:
3005	/* we should warn... */	3004	/* we should warn... */
3006	return;	3005	return;
3007	}	3006	}
3008	if (args->next) {	3007	if (args->next) {
3009	printf("\n");	3008	printf("\n");
3010	print_args(args->next);	3009	print_args(args->next);
3011	}	3010	}
3012	}	3011	}
3013		3012
3014	int parse_ftrace_file(char *buf, unsigned long size)	3013	int parse_ftrace_file(char *buf, unsigned long size)
3015	{	3014	{
3016	struct format_field *field;	3015	struct format_field *field;
3017	struct print_arg arg, *list;	3016	struct print_arg arg, *list;
3018	struct event *event;	3017	struct event *event;
3019	int ret;	3018	int ret;
3020		3019
3021	init_input_buf(buf, size);	3020	init_input_buf(buf, size);
3022		3021
3023	event = alloc_event();	3022	event = alloc_event();
3024	if (!event)	3023	if (!event)
3025	return -ENOMEM;	3024	return -ENOMEM;
3026		3025
3027	event->flags \|= EVENT_FL_ISFTRACE;	3026	event->flags \|= EVENT_FL_ISFTRACE;
3028		3027
3029	event->name = event_read_name();	3028	event->name = event_read_name();
3030	if (!event->name)	3029	if (!event->name)
3031	die("failed to read ftrace event name");	3030	die("failed to read ftrace event name");
3032		3031
3033	if (strcmp(event->name, "function") == 0)	3032	if (strcmp(event->name, "function") == 0)
3034	event->flags \|= EVENT_FL_ISFUNC;	3033	event->flags \|= EVENT_FL_ISFUNC;
3035		3034
3036	else if (strcmp(event->name, "funcgraph_entry") == 0)	3035	else if (strcmp(event->name, "funcgraph_entry") == 0)
3037	event->flags \|= EVENT_FL_ISFUNCENT;	3036	event->flags \|= EVENT_FL_ISFUNCENT;
3038		3037
3039	else if (strcmp(event->name, "funcgraph_exit") == 0)	3038	else if (strcmp(event->name, "funcgraph_exit") == 0)
3040	event->flags \|= EVENT_FL_ISFUNCRET;	3039	event->flags \|= EVENT_FL_ISFUNCRET;
3041		3040
3042	else if (strcmp(event->name, "bprint") == 0)	3041	else if (strcmp(event->name, "bprint") == 0)
3043	event->flags \|= EVENT_FL_ISBPRINT;	3042	event->flags \|= EVENT_FL_ISBPRINT;
3044		3043
3045	event->id = event_read_id();	3044	event->id = event_read_id();
3046	if (event->id < 0)	3045	if (event->id < 0)
3047	die("failed to read ftrace event id");	3046	die("failed to read ftrace event id");
3048		3047
3049	add_event(event);	3048	add_event(event);
3050		3049
3051	ret = event_read_format(event);	3050	ret = event_read_format(event);
3052	if (ret < 0)	3051	if (ret < 0)
3053	die("failed to read ftrace event format");	3052	die("failed to read ftrace event format");
3054		3053
3055	ret = event_read_print(event);	3054	ret = event_read_print(event);
3056	if (ret < 0)	3055	if (ret < 0)
3057	die("failed to read ftrace event print fmt");	3056	die("failed to read ftrace event print fmt");
3058		3057
3059	/* New ftrace handles args */	3058	/* New ftrace handles args */
3060	if (ret > 0)	3059	if (ret > 0)
3061	return 0;	3060	return 0;
3062	/*	3061	/*
3063	* The arguments for ftrace files are parsed by the fields.	3062	* The arguments for ftrace files are parsed by the fields.
3064	* Set up the fields as their arguments.	3063	* Set up the fields as their arguments.
3065	*/	3064	*/
3066	list = &event->print_fmt.args;	3065	list = &event->print_fmt.args;
3067	for (field = event->format.fields; field; field = field->next) {	3066	for (field = event->format.fields; field; field = field->next) {
3068	arg = malloc_or_die(sizeof(*arg));	3067	arg = malloc_or_die(sizeof(*arg));
3069	memset(arg, 0, sizeof(*arg));	3068	memset(arg, 0, sizeof(*arg));
3070	*list = arg;	3069	*list = arg;
3071	list = &arg->next;	3070	list = &arg->next;
3072	arg->type = PRINT_FIELD;	3071	arg->type = PRINT_FIELD;
3073	arg->field.name = field->name;	3072	arg->field.name = field->name;
3074	arg->field.field = field;	3073	arg->field.field = field;
3075	}	3074	}
3076	return 0;	3075	return 0;
3077	}	3076	}
3078		3077
3079	int parse_event_file(char buf, unsigned long size, char sys)	3078	int parse_event_file(char buf, unsigned long size, char sys)
3080	{	3079	{
3081	struct event *event;	3080	struct event *event;
3082	int ret;	3081	int ret;
3083		3082
3084	init_input_buf(buf, size);	3083	init_input_buf(buf, size);
3085		3084
3086	event = alloc_event();	3085	event = alloc_event();
3087	if (!event)	3086	if (!event)
3088	return -ENOMEM;	3087	return -ENOMEM;
3089		3088
3090	event->name = event_read_name();	3089	event->name = event_read_name();
3091	if (!event->name)	3090	if (!event->name)
3092	die("failed to read event name");	3091	die("failed to read event name");
3093		3092
3094	event->id = event_read_id();	3093	event->id = event_read_id();
3095	if (event->id < 0)	3094	if (event->id < 0)
3096	die("failed to read event id");	3095	die("failed to read event id");
3097		3096
3098	ret = event_read_format(event);	3097	ret = event_read_format(event);
3099	if (ret < 0) {	3098	if (ret < 0) {
3100	warning("failed to read event format for %s", event->name);	3099	warning("failed to read event format for %s", event->name);
3101	goto event_failed;	3100	goto event_failed;
3102	}	3101	}
3103		3102
3104	ret = event_read_print(event);	3103	ret = event_read_print(event);
3105	if (ret < 0) {	3104	if (ret < 0) {
3106	warning("failed to read event print fmt for %s", event->name);	3105	warning("failed to read event print fmt for %s", event->name);
3107	goto event_failed;	3106	goto event_failed;
3108	}	3107	}
3109		3108
3110	event->system = strdup(sys);	3109	event->system = strdup(sys);
3111		3110
3112	#define PRINT_ARGS 0	3111	#define PRINT_ARGS 0
3113	if (PRINT_ARGS && event->print_fmt.args)	3112	if (PRINT_ARGS && event->print_fmt.args)
3114	print_args(event->print_fmt.args);	3113	print_args(event->print_fmt.args);
3115		3114
3116	add_event(event);	3115	add_event(event);
3117	return 0;	3116	return 0;
3118		3117
3119	event_failed:	3118	event_failed:
3120	event->flags \|= EVENT_FL_FAILED;	3119	event->flags \|= EVENT_FL_FAILED;
3121	/* still add it even if it failed */	3120	/* still add it even if it failed */
3122	add_event(event);	3121	add_event(event);
3123	return -1;	3122	return -1;
3124	}	3123	}
3125		3124
3126	void parse_set_info(int nr_cpus, int long_sz)	3125	void parse_set_info(int nr_cpus, int long_sz)
3127	{	3126	{
3128	cpus = nr_cpus;	3127	cpus = nr_cpus;
3129	long_size = long_sz;	3128	long_size = long_sz;
3130	}	3129	}
3131		3130
3132	int common_pc(struct scripting_context *context)	3131	int common_pc(struct scripting_context *context)
3133	{	3132	{
3134	return parse_common_pc(context->event_data);	3133	return parse_common_pc(context->event_data);
3135	}	3134	}
3136		3135
3137	int common_flags(struct scripting_context *context)	3136	int common_flags(struct scripting_context *context)
3138	{	3137	{
3139	return parse_common_flags(context->event_data);	3138	return parse_common_flags(context->event_data);
3140	}	3139	}
3141		3140
3142	int common_lock_depth(struct scripting_context *context)	3141	int common_lock_depth(struct scripting_context *context)
3143	{	3142	{
3144	return parse_common_lock_depth(context->event_data);	3143	return parse_common_lock_depth(context->event_data);
3145	}	3144	}
3146		3145

tools/perf/util/ui/browsers/hists.c

Diff comments View file @ 0a84f00

-#define _GNU_SOURCE
 #include <stdio.h>
-#undef _GNU_SOURCE
 #include "../libslang.h"
 #include <stdlib.h>
 #include <string.h>
 #include <newt.h>
 #include <linux/rbtree.h>
 #include "../../evsel.h"
 #include "../../evlist.h"
 #include "../../hist.h"
 #include "../../pstack.h"
 #include "../../sort.h"
 #include "../../util.h"
 #include "../browser.h"
 #include "../helpline.h"
 #include "../util.h"
 #include "../ui.h"
 #include "map.h"
 struct hist_browser {
 	struct ui_browser   b;
 	struct hists	    *hists;
 	struct hist_entry   *he_selection;
 	struct map_symbol   *selection;
 	bool		     has_symbols;
 };
 static int hists__browser_title(struct hists *self, char *bf, size_t size,
 				const char *ev_name);
 static void hist_browser__refresh_dimensions(struct hist_browser *self)
 {
 	/* 3 == +/- toggle symbol before actual hist_entry rendering */
 	self->b.width = 3 + (hists__sort_list_width(self->hists) +
 			     sizeof("[k]"));
 }
 static void hist_browser__reset(struct hist_browser *self)
 {
 	self->b.nr_entries = self->hists->nr_entries;
 	hist_browser__refresh_dimensions(self);
 	ui_browser__reset_index(&self->b);
 }
 static char tree__folded_sign(bool unfolded)
 {
 	return unfolded ? '-' : '+';
 }
 static char map_symbol__folded(const struct map_symbol *self)
 {
 	return self->has_children ? tree__folded_sign(self->unfolded) : ' ';
 }
 static char hist_entry__folded(const struct hist_entry *self)
 {
 	return map_symbol__folded(&self->ms);
 }
 static char callchain_list__folded(const struct callchain_list *self)
 {
 	return map_symbol__folded(&self->ms);
 }
 static void map_symbol__set_folding(struct map_symbol *self, bool unfold)
 {
 	self->unfolded = unfold ? self->has_children : false;
 }
 static int callchain_node__count_rows_rb_tree(struct callchain_node *self)
 {
 	int n = 0;
 	struct rb_node *nd;
 	for (nd = rb_first(&self->rb_root); nd; nd = rb_next(nd)) {
 		struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
 		struct callchain_list *chain;
 		char folded_sign = ' '; /* No children */
 		list_for_each_entry(chain, &child->val, list) {
 			++n;
 			/* We need this because we may not have children */
 			folded_sign = callchain_list__folded(chain);
 			if (folded_sign == '+')
 				break;
 		}
 		if (folded_sign == '-') /* Have children and they're unfolded */
 			n += callchain_node__count_rows_rb_tree(child);
 	}
 	return n;
 }
 static int callchain_node__count_rows(struct callchain_node *node)
 {
 	struct callchain_list *chain;
 	bool unfolded = false;
 	int n = 0;
 	list_for_each_entry(chain, &node->val, list) {
 		++n;
 		unfolded = chain->ms.unfolded;
 	}
 	if (unfolded)
 		n += callchain_node__count_rows_rb_tree(node);
 	return n;
 }
 static int callchain__count_rows(struct rb_root *chain)
 {
 	struct rb_node *nd;
 	int n = 0;
 	for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
 		struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
 		n += callchain_node__count_rows(node);
 	}
 	return n;
 }
 static bool map_symbol__toggle_fold(struct map_symbol *self)
 {
 	if (!self->has_children)
 		return false;
 	self->unfolded = !self->unfolded;
 	return true;
 }
 static void callchain_node__init_have_children_rb_tree(struct callchain_node *self)
 {
 	struct rb_node *nd = rb_first(&self->rb_root);
 	for (nd = rb_first(&self->rb_root); nd; nd = rb_next(nd)) {
 		struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
 		struct callchain_list *chain;
 		bool first = true;
 		list_for_each_entry(chain, &child->val, list) {
 			if (first) {
 				first = false;
 				chain->ms.has_children = chain->list.next != &child->val ||
 							 !RB_EMPTY_ROOT(&child->rb_root);
 			} else
 				chain->ms.has_children = chain->list.next == &child->val &&
 							 !RB_EMPTY_ROOT(&child->rb_root);
 		}
 		callchain_node__init_have_children_rb_tree(child);
 	}
 }
 static void callchain_node__init_have_children(struct callchain_node *self)
 {
 	struct callchain_list *chain;
 	list_for_each_entry(chain, &self->val, list)
 		chain->ms.has_children = !RB_EMPTY_ROOT(&self->rb_root);
 	callchain_node__init_have_children_rb_tree(self);
 }
 static void callchain__init_have_children(struct rb_root *self)
 {
 	struct rb_node *nd;
 	for (nd = rb_first(self); nd; nd = rb_next(nd)) {
 		struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
 		callchain_node__init_have_children(node);
 	}
 }
 static void hist_entry__init_have_children(struct hist_entry *self)
 {
 	if (!self->init_have_children) {
 		self->ms.has_children = !RB_EMPTY_ROOT(&self->sorted_chain);
 		callchain__init_have_children(&self->sorted_chain);
 		self->init_have_children = true;
 	}
 }
 static bool hist_browser__toggle_fold(struct hist_browser *self)
 {
 	if (map_symbol__toggle_fold(self->selection)) {
 		struct hist_entry *he = self->he_selection;
 		hist_entry__init_have_children(he);
 		self->hists->nr_entries -= he->nr_rows;
 		if (he->ms.unfolded)
 			he->nr_rows = callchain__count_rows(&he->sorted_chain);
 		else
 			he->nr_rows = 0;
 		self->hists->nr_entries += he->nr_rows;
 		self->b.nr_entries = self->hists->nr_entries;
 		return true;
 	}
 	/* If it doesn't have children, no toggling performed */
 	return false;
 }
 static int callchain_node__set_folding_rb_tree(struct callchain_node *self, bool unfold)
 {
 	int n = 0;
 	struct rb_node *nd;
 	for (nd = rb_first(&self->rb_root); nd; nd = rb_next(nd)) {
 		struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
 		struct callchain_list *chain;
 		bool has_children = false;
 		list_for_each_entry(chain, &child->val, list) {
 			++n;
 			map_symbol__set_folding(&chain->ms, unfold);
 			has_children = chain->ms.has_children;
 		}
 		if (has_children)
 			n += callchain_node__set_folding_rb_tree(child, unfold);
 	}
 	return n;
 }
 static int callchain_node__set_folding(struct callchain_node *node, bool unfold)
 {
 	struct callchain_list *chain;
 	bool has_children = false;
 	int n = 0;
 	list_for_each_entry(chain, &node->val, list) {
 		++n;
 		map_symbol__set_folding(&chain->ms, unfold);
 		has_children = chain->ms.has_children;
 	}
 	if (has_children)
 		n += callchain_node__set_folding_rb_tree(node, unfold);
 	return n;
 }
 static int callchain__set_folding(struct rb_root *chain, bool unfold)
 {
 	struct rb_node *nd;
 	int n = 0;
 	for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
 		struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
 		n += callchain_node__set_folding(node, unfold);
 	}
 	return n;
 }
 static void hist_entry__set_folding(struct hist_entry *self, bool unfold)
 {
 	hist_entry__init_have_children(self);
 	map_symbol__set_folding(&self->ms, unfold);
 	if (self->ms.has_children) {
 		int n = callchain__set_folding(&self->sorted_chain, unfold);
 		self->nr_rows = unfold ? n : 0;
 	} else
 		self->nr_rows = 0;
 }
 static void hists__set_folding(struct hists *self, bool unfold)
 {
 	struct rb_node *nd;
 	self->nr_entries = 0;
 	for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
 		struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
 		hist_entry__set_folding(he, unfold);
 		self->nr_entries += 1 + he->nr_rows;
 	}
 }
 static void hist_browser__set_folding(struct hist_browser *self, bool unfold)
 {
 	hists__set_folding(self->hists, unfold);
 	self->b.nr_entries = self->hists->nr_entries;
 	/* Go to the start, we may be way after valid entries after a collapse */
 	ui_browser__reset_index(&self->b);
 }
 static void ui_browser__warn_lost_events(struct ui_browser *browser)
 {
 	ui_browser__warning(browser, 4,
 		"Events are being lost, check IO/CPU overload!\n\n"
 		"You may want to run 'perf' using a RT scheduler policy:\n\n"
 		" perf top -r 80\n\n"
 		"Or reduce the sampling frequency.");
 }
 static int hist_browser__run(struct hist_browser *self, const char *ev_name,
 			     void(*timer)(void *arg), void *arg, int delay_secs)
 {
 	int key;
 	char title[160];
 	self->b.entries = &self->hists->entries;
 	self->b.nr_entries = self->hists->nr_entries;
 	hist_browser__refresh_dimensions(self);
 	hists__browser_title(self->hists, title, sizeof(title), ev_name);
 	if (ui_browser__show(&self->b, title,
 			     "Press '?' for help on key bindings") < 0)
 		return -1;
 	while (1) {
 		key = ui_browser__run(&self->b, delay_secs);
 		switch (key) {
 		case K_TIMER:
 			timer(arg);
 			ui_browser__update_nr_entries(&self->b, self->hists->nr_entries);
 			if (self->hists->stats.nr_lost_warned !=
 			    self->hists->stats.nr_events[PERF_RECORD_LOST]) {
 				self->hists->stats.nr_lost_warned =
 					self->hists->stats.nr_events[PERF_RECORD_LOST];
 				ui_browser__warn_lost_events(&self->b);
 			}
 			hists__browser_title(self->hists, title, sizeof(title), ev_name);
 			ui_browser__show_title(&self->b, title);
 			continue;
 		case 'D': { /* Debug */
 			static int seq;
 			struct hist_entry *h = rb_entry(self->b.top,
 							struct hist_entry, rb_node);
 			ui_helpline__pop();
 			ui_helpline__fpush("%d: nr_ent=(%d,%d), height=%d, idx=%d, fve: idx=%d, row_off=%d, nrows=%d",
 					   seq++, self->b.nr_entries,
 					   self->hists->nr_entries,
 					   self->b.height,
 					   self->b.index,
 					   self->b.top_idx,
 					   h->row_offset, h->nr_rows);
 		}
 			break;
 		case 'C':
 			/* Collapse the whole world. */
 			hist_browser__set_folding(self, false);
 			break;
 		case 'E':
 			/* Expand the whole world. */
 			hist_browser__set_folding(self, true);
 			break;
 		case K_ENTER:
 			if (hist_browser__toggle_fold(self))
 				break;
 			/* fall thru */
 		default:
 			goto out;
 		}
 	}
 out:
 	ui_browser__hide(&self->b);
 	return key;
 }
 static char *callchain_list__sym_name(struct callchain_list *self,
 				      char *bf, size_t bfsize)
 {
 	if (self->ms.sym)
 		return self->ms.sym->name;
 	snprintf(bf, bfsize, "%#" PRIx64, self->ip);
 	return bf;
 }
 #define LEVEL_OFFSET_STEP 3
 static int hist_browser__show_callchain_node_rb_tree(struct hist_browser *self,
 						     struct callchain_node *chain_node,
 						     u64 total, int level,
 						     unsigned short row,
 						     off_t *row_offset,
 						     bool *is_current_entry)
 {
 	struct rb_node *node;
 	int first_row = row, width, offset = level * LEVEL_OFFSET_STEP;
 	u64 new_total, remaining;
 	if (callchain_param.mode == CHAIN_GRAPH_REL)
 		new_total = chain_node->children_hit;
 	else
 		new_total = total;
 	remaining = new_total;
 	node = rb_first(&chain_node->rb_root);
 	while (node) {
 		struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
 		struct rb_node *next = rb_next(node);
 		u64 cumul = callchain_cumul_hits(child);
 		struct callchain_list *chain;
 		char folded_sign = ' ';
 		int first = true;
 		int extra_offset = 0;
 		remaining -= cumul;
 		list_for_each_entry(chain, &child->val, list) {
 			char ipstr[BITS_PER_LONG / 4 + 1], *alloc_str;
 			const char *str;
 			int color;
 			bool was_first = first;
 			if (first)
 				first = false;
 			else
 				extra_offset = LEVEL_OFFSET_STEP;
 			folded_sign = callchain_list__folded(chain);
 			if (*row_offset != 0) {
 				--*row_offset;
 				goto do_next;
 			}
 			alloc_str = NULL;
 			str = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
 			if (was_first) {
 				double percent = cumul * 100.0 / new_total;
 				if (asprintf(&alloc_str, "%2.2f%% %s", percent, str) < 0)
 					str = "Not enough memory!";
 				else
 					str = alloc_str;
 			}
 			color = HE_COLORSET_NORMAL;
 			width = self->b.width - (offset + extra_offset + 2);
 			if (ui_browser__is_current_entry(&self->b, row)) {
 				self->selection = &chain->ms;
 				color = HE_COLORSET_SELECTED;
 				*is_current_entry = true;
 			}
 			ui_browser__set_color(&self->b, color);
 			ui_browser__gotorc(&self->b, row, 0);
 			slsmg_write_nstring(" ", offset + extra_offset);
 			slsmg_printf("%c ", folded_sign);
 			slsmg_write_nstring(str, width);
 			free(alloc_str);
 			if (++row == self->b.height)
 				goto out;
 do_next:
 			if (folded_sign == '+')
 				break;
 		}
 		if (folded_sign == '-') {
 			const int new_level = level + (extra_offset ? 2 : 1);
 			row += hist_browser__show_callchain_node_rb_tree(self, child, new_total,
 									 new_level, row, row_offset,
 									 is_current_entry);
 		}
 		if (row == self->b.height)
 			goto out;
 		node = next;
 	}
 out:
 	return row - first_row;
 }
 static int hist_browser__show_callchain_node(struct hist_browser *self,
 					     struct callchain_node *node,
 					     int level, unsigned short row,
 					     off_t *row_offset,
 					     bool *is_current_entry)
 {
 	struct callchain_list *chain;
 	int first_row = row,
 	     offset = level * LEVEL_OFFSET_STEP,
 	     width = self->b.width - offset;
 	char folded_sign = ' ';
 	list_for_each_entry(chain, &node->val, list) {
 		char ipstr[BITS_PER_LONG / 4 + 1], *s;
 		int color;
 		folded_sign = callchain_list__folded(chain);
 		if (*row_offset != 0) {
 			--*row_offset;
 			continue;
 		}
 		color = HE_COLORSET_NORMAL;
 		if (ui_browser__is_current_entry(&self->b, row)) {
 			self->selection = &chain->ms;
 			color = HE_COLORSET_SELECTED;
 			*is_current_entry = true;
 		}
 		s = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
 		ui_browser__gotorc(&self->b, row, 0);
 		ui_browser__set_color(&self->b, color);
 		slsmg_write_nstring(" ", offset);
 		slsmg_printf("%c ", folded_sign);
 		slsmg_write_nstring(s, width - 2);
 		if (++row == self->b.height)
 			goto out;
 	}
 	if (folded_sign == '-')
 		row += hist_browser__show_callchain_node_rb_tree(self, node,
 								 self->hists->stats.total_period,
 								 level + 1, row,
 								 row_offset,
 								 is_current_entry);
 out:
 	return row - first_row;
 }
 static int hist_browser__show_callchain(struct hist_browser *self,
 					struct rb_root *chain,
 					int level, unsigned short row,
 					off_t *row_offset,
 					bool *is_current_entry)
 {
 	struct rb_node *nd;
 	int first_row = row;
 	for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
 		struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
 		row += hist_browser__show_callchain_node(self, node, level,
 							 row, row_offset,
 							 is_current_entry);
 		if (row == self->b.height)
 			break;
 	}
 	return row - first_row;
 }
 static int hist_browser__show_entry(struct hist_browser *self,
 				    struct hist_entry *entry,
 				    unsigned short row)
 {
 	char s[256];
 	double percent;
 	int printed = 0;
 	int width = self->b.width - 6; /* The percentage */
 	char folded_sign = ' ';
 	bool current_entry = ui_browser__is_current_entry(&self->b, row);
 	off_t row_offset = entry->row_offset;
 	if (current_entry) {
 		self->he_selection = entry;
 		self->selection = &entry->ms;
 	}
 	if (symbol_conf.use_callchain) {
 		hist_entry__init_have_children(entry);
 		folded_sign = hist_entry__folded(entry);
 	}
 	if (row_offset == 0) {
 		hist_entry__snprintf(entry, s, sizeof(s), self->hists);
 		percent = (entry->period * 100.0) / self->hists->stats.total_period;
 		ui_browser__set_percent_color(&self->b, percent, current_entry);
 		ui_browser__gotorc(&self->b, row, 0);
 		if (symbol_conf.use_callchain) {
 			slsmg_printf("%c ", folded_sign);
 			width -= 2;
 		}
 		slsmg_printf(" %5.2f%%", percent);
 		/* The scroll bar isn't being used */
 		if (!self->b.navkeypressed)
 			width += 1;
 		if (!current_entry || !self->b.navkeypressed)
 			ui_browser__set_color(&self->b, HE_COLORSET_NORMAL);
 		if (symbol_conf.show_nr_samples) {
 			slsmg_printf(" %11u", entry->nr_events);
 			width -= 12;
 		}
 		if (symbol_conf.show_total_period) {
 			slsmg_printf(" %12" PRIu64, entry->period);
 			width -= 13;
 		}
 		slsmg_write_nstring(s, width);
 		++row;
 		++printed;
 	} else
 		--row_offset;
 	if (folded_sign == '-' && row != self->b.height) {
 		printed += hist_browser__show_callchain(self, &entry->sorted_chain,
 							1, row, &row_offset,
 							&current_entry);
 		if (current_entry)
 			self->he_selection = entry;
 	}
 	return printed;
 }
 static void ui_browser__hists_init_top(struct ui_browser *browser)
 {
 	if (browser->top == NULL) {
 		struct hist_browser *hb;
 		hb = container_of(browser, struct hist_browser, b);
 		browser->top = rb_first(&hb->hists->entries);
 	}
 }
 static unsigned int hist_browser__refresh(struct ui_browser *self)
 {
 	unsigned row = 0;
 	struct rb_node *nd;
 	struct hist_browser *hb = container_of(self, struct hist_browser, b);
 	ui_browser__hists_init_top(self);
 	for (nd = self->top; nd; nd = rb_next(nd)) {
 		struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 		if (h->filtered)
 			continue;
 		row += hist_browser__show_entry(hb, h, row);
 		if (row == self->height)
 			break;
 	}
 	return row;
 }
 static struct rb_node *hists__filter_entries(struct rb_node *nd)
 {
 	while (nd != NULL) {
 		struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 		if (!h->filtered)
 			return nd;
 		nd = rb_next(nd);
 	}
 	return NULL;
 }
 static struct rb_node *hists__filter_prev_entries(struct rb_node *nd)
 {
 	while (nd != NULL) {
 		struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 		if (!h->filtered)
 			return nd;
 		nd = rb_prev(nd);
 	}
 	return NULL;
 }
 static void ui_browser__hists_seek(struct ui_browser *self,
 				   off_t offset, int whence)
 {
 	struct hist_entry *h;
 	struct rb_node *nd;
 	bool first = true;
 	if (self->nr_entries == 0)
 		return;
 	ui_browser__hists_init_top(self);
 	switch (whence) {
 	case SEEK_SET:
 		nd = hists__filter_entries(rb_first(self->entries));
 		break;
 	case SEEK_CUR:
 		nd = self->top;
 		goto do_offset;
 	case SEEK_END:
 		nd = hists__filter_prev_entries(rb_last(self->entries));
 		first = false;
 		break;
 	default:
 		return;
 	}
 	/*
 	 * Moves not relative to the first visible entry invalidates its
 	 * row_offset:
 	 */
 	h = rb_entry(self->top, struct hist_entry, rb_node);
 	h->row_offset = 0;
 	/*
 	 * Here we have to check if nd is expanded (+), if it is we can't go
 	 * the next top level hist_entry, instead we must compute an offset of
 	 * what _not_ to show and not change the first visible entry.
 	 *
 	 * This offset increments when we are going from top to bottom and
 	 * decreases when we're going from bottom to top.
 	 *
 	 * As we don't have backpointers to the top level in the callchains
 	 * structure, we need to always print the whole hist_entry callchain,
 	 * skipping the first ones that are before the first visible entry
 	 * and stop when we printed enough lines to fill the screen.
 	 */
 do_offset:
 	if (offset > 0) {
 		do {
 			h = rb_entry(nd, struct hist_entry, rb_node);
 			if (h->ms.unfolded) {
 				u16 remaining = h->nr_rows - h->row_offset;
 				if (offset > remaining) {
 					offset -= remaining;
 					h->row_offset = 0;
 				} else {
 					h->row_offset += offset;
 					offset = 0;
 					self->top = nd;
 					break;
 				}
 			}
 			nd = hists__filter_entries(rb_next(nd));
 			if (nd == NULL)
 				break;
 			--offset;
 			self->top = nd;
 		} while (offset != 0);
 	} else if (offset < 0) {
 		while (1) {
 			h = rb_entry(nd, struct hist_entry, rb_node);
 			if (h->ms.unfolded) {
 				if (first) {
 					if (-offset > h->row_offset) {
 						offset += h->row_offset;
 						h->row_offset = 0;
 					} else {
 						h->row_offset += offset;
 						offset = 0;
 						self->top = nd;
 						break;
 					}
 				} else {
 					if (-offset > h->nr_rows) {
 						offset += h->nr_rows;
 						h->row_offset = 0;
 					} else {
 						h->row_offset = h->nr_rows + offset;
 						offset = 0;
 						self->top = nd;
 						break;
 					}
 				}
 			}
 			nd = hists__filter_prev_entries(rb_prev(nd));
 			if (nd == NULL)
 				break;
 			++offset;
 			self->top = nd;
 			if (offset == 0) {
 				/*
 				 * Last unfiltered hist_entry, check if it is
 				 * unfolded, if it is then we should have
 				 * row_offset at its last entry.
 				 */
 				h = rb_entry(nd, struct hist_entry, rb_node);
 				if (h->ms.unfolded)
 					h->row_offset = h->nr_rows;
 				break;
 			}
 			first = false;
 		}
 	} else {
 		self->top = nd;
 		h = rb_entry(nd, struct hist_entry, rb_node);
 		h->row_offset = 0;
 	}
 }
 static struct hist_browser *hist_browser__new(struct hists *hists)
 {
 	struct hist_browser *self = zalloc(sizeof(*self));
 	if (self) {
 		self->hists = hists;
 		self->b.refresh = hist_browser__refresh;
 		self->b.seek = ui_browser__hists_seek;
 		self->b.use_navkeypressed = true,
 		self->has_symbols = sort_sym.list.next != NULL;
 	}
 	return self;
 }
 static void hist_browser__delete(struct hist_browser *self)
 {
 	free(self);
 }
 static struct hist_entry *hist_browser__selected_entry(struct hist_browser *self)
 {
 	return self->he_selection;
 }
 static struct thread *hist_browser__selected_thread(struct hist_browser *self)
 {
 	return self->he_selection->thread;
 }
 static int hists__browser_title(struct hists *self, char *bf, size_t size,
 				const char *ev_name)
 {
 	char unit;
 	int printed;
 	const struct dso *dso = self->dso_filter;
 	const struct thread *thread = self->thread_filter;
 	unsigned long nr_events = self->stats.nr_events[PERF_RECORD_SAMPLE];
 	nr_events = convert_unit(nr_events, &unit);
 	printed = snprintf(bf, size, "Events: %lu%c %s", nr_events, unit, ev_name);
 	if (thread)
 		printed += snprintf(bf + printed, size - printed,
 				    ", Thread: %s(%d)",
 				    (thread->comm_set ? thread->comm : ""),
 				    thread->pid);
 	if (dso)
 		printed += snprintf(bf + printed, size - printed,
 				    ", DSO: %s", dso->short_name);
 	return printed;
 }
 static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
 				    const char *helpline, const char *ev_name,
 				    bool left_exits,
 				    void(*timer)(void *arg), void *arg,
 				    int delay_secs)
 {
 	struct hists *self = &evsel->hists;
 	struct hist_browser *browser = hist_browser__new(self);
 	struct pstack *fstack;
 	int key = -1;
 	if (browser == NULL)
 		return -1;
 	fstack = pstack__new(2);
 	if (fstack == NULL)
 		goto out;
 	ui_helpline__push(helpline);
 	while (1) {
 		const struct thread *thread = NULL;
 		const struct dso *dso = NULL;
 		char *options[16];
 		int nr_options = 0, choice = 0, i,
 		    annotate = -2, zoom_dso = -2, zoom_thread = -2,
 		    browse_map = -2;
 		key = hist_browser__run(browser, ev_name, timer, arg, delay_secs);
 		if (browser->he_selection != NULL) {
 			thread = hist_browser__selected_thread(browser);
 			dso = browser->selection->map ? browser->selection->map->dso : NULL;
 		}
 		switch (key) {
 		case K_TAB:
 		case K_UNTAB:
 			if (nr_events == 1)
 				continue;
 			/*
 			 * Exit the browser, let hists__browser_tree
 			 * go to the next or previous
 			 */
 			goto out_free_stack;
 		case 'a':
 			if (!browser->has_symbols) {
 				ui_browser__warning(&browser->b, delay_secs * 2,
 			"Annotation is only available for symbolic views, "
 			"include \"sym\" in --sort to use it.");
 				continue;
 			}
 			if (browser->selection == NULL ||
 			    browser->selection->sym == NULL ||
 			    browser->selection->map->dso->annotate_warned)
 				continue;
 			goto do_annotate;
 		case 'd':
 			goto zoom_dso;
 		case 't':
 			goto zoom_thread;
 		case K_F1:
 		case 'h':
 		case '?':
 			ui_browser__help_window(&browser->b,
 					"h/?/F1        Show this window\n"
 					"UP/DOWN/PGUP\n"
 					"PGDN/SPACE    Navigate\n"
 					"q/ESC/CTRL+C  Exit browser\n\n"
 					"For multiple event sessions:\n\n"
 					"TAB/UNTAB Switch events\n\n"
 					"For symbolic views (--sort has sym):\n\n"
 					"->            Zoom into DSO/Threads & Annotate current symbol\n"
 					"<-            Zoom out\n"
 					"a             Annotate current symbol\n"
 					"C             Collapse all callchains\n"
 					"E             Expand all callchains\n"
 					"d             Zoom into current DSO\n"
 					"t             Zoom into current Thread");
 			continue;
 		case K_ENTER:
 		case K_RIGHT:
 			/* menu */
 			break;
 		case K_LEFT: {
 			const void *top;
 			if (pstack__empty(fstack)) {
 				/*
 				 * Go back to the perf_evsel_menu__run or other user
 				 */
 				if (left_exits)
 					goto out_free_stack;
 				continue;
 			}
 			top = pstack__pop(fstack);
 			if (top == &browser->hists->dso_filter)
 				goto zoom_out_dso;
 			if (top == &browser->hists->thread_filter)
 				goto zoom_out_thread;
 			continue;
 		}
 		case K_ESC:
 			if (!left_exits &&
 			    !ui_browser__dialog_yesno(&browser->b,
 					       "Do you really want to exit?"))
 				continue;
 			/* Fall thru */
 		case 'q':
 		case CTRL('c'):
 			goto out_free_stack;
 		default:
 			continue;
 		}
 		if (!browser->has_symbols)
 			goto add_exit_option;
 		if (browser->selection != NULL &&
 		    browser->selection->sym != NULL &&
 		    !browser->selection->map->dso->annotate_warned &&
 		    asprintf(&options[nr_options], "Annotate %s",
 			     browser->selection->sym->name) > 0)
 			annotate = nr_options++;
 		if (thread != NULL &&
 		    asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
 			     (browser->hists->thread_filter ? "out of" : "into"),
 			     (thread->comm_set ? thread->comm : ""),
 			     thread->pid) > 0)
 			zoom_thread = nr_options++;
 		if (dso != NULL &&
 		    asprintf(&options[nr_options], "Zoom %s %s DSO",
 			     (browser->hists->dso_filter ? "out of" : "into"),
 			     (dso->kernel ? "the Kernel" : dso->short_name)) > 0)
 			zoom_dso = nr_options++;
 		if (browser->selection != NULL &&
 		    browser->selection->map != NULL &&
 		    asprintf(&options[nr_options], "Browse map details") > 0)
 			browse_map = nr_options++;
 add_exit_option:
 		options[nr_options++] = (char *)"Exit";
 		choice = ui__popup_menu(nr_options, options);
 		for (i = 0; i < nr_options - 1; ++i)
 			free(options[i]);
 		if (choice == nr_options - 1)
 			break;
 		if (choice == -1)
 			continue;
 		if (choice == annotate) {
 			struct hist_entry *he;
 			int err;
 do_annotate:
 			he = hist_browser__selected_entry(browser);
 			if (he == NULL)
 				continue;
 			/*
 			 * Don't let this be freed, say, by hists__decay_entry.
 			 */
 			he->used = true;
 			err = hist_entry__tui_annotate(he, evsel->idx,
 						       timer, arg, delay_secs);
 			he->used = false;
 			ui_browser__update_nr_entries(&browser->b, browser->hists->nr_entries);
 			if (err)
 				ui_browser__handle_resize(&browser->b);
 		} else if (choice == browse_map)
 			map__browse(browser->selection->map);
 		else if (choice == zoom_dso) {
 zoom_dso:
 			if (browser->hists->dso_filter) {
 				pstack__remove(fstack, &browser->hists->dso_filter);
 zoom_out_dso:
 				ui_helpline__pop();
 				browser->hists->dso_filter = NULL;
 				sort_dso.elide = false;
 			} else {
 				if (dso == NULL)
 					continue;
 				ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s DSO\"",
 						   dso->kernel ? "the Kernel" : dso->short_name);
 				browser->hists->dso_filter = dso;
 				sort_dso.elide = true;
 				pstack__push(fstack, &browser->hists->dso_filter);
 			}
 			hists__filter_by_dso(self);
 			hist_browser__reset(browser);
 		} else if (choice == zoom_thread) {
 zoom_thread:
 			if (browser->hists->thread_filter) {
 				pstack__remove(fstack, &browser->hists->thread_filter);
 zoom_out_thread:
 				ui_helpline__pop();
 				browser->hists->thread_filter = NULL;
 				sort_thread.elide = false;
 			} else {
 				ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s(%d) thread\"",
 						   thread->comm_set ? thread->comm : "",
 						   thread->pid);
 				browser->hists->thread_filter = thread;
 				sort_thread.elide = true;
 				pstack__push(fstack, &browser->hists->thread_filter);
 			}
 			hists__filter_by_thread(self);
 			hist_browser__reset(browser);
 		}
 	}
 out_free_stack:
 	pstack__delete(fstack);
 out:
 	hist_browser__delete(browser);
 	return key;
 }
 struct perf_evsel_menu {
 	struct ui_browser b;
 	struct perf_evsel *selection;
 	bool lost_events, lost_events_warned;
 };
 static void perf_evsel_menu__write(struct ui_browser *browser,
 				   void *entry, int row)
 {
 	struct perf_evsel_menu *menu = container_of(browser,
 						    struct perf_evsel_menu, b);
 	struct perf_evsel *evsel = list_entry(entry, struct perf_evsel, node);
 	bool current_entry = ui_browser__is_current_entry(browser, row);
 	unsigned long nr_events = evsel->hists.stats.nr_events[PERF_RECORD_SAMPLE];
 	const char *ev_name = event_name(evsel);
 	char bf[256], unit;
 	const char *warn = " ";
 	size_t printed;
 	ui_browser__set_color(browser, current_entry ? HE_COLORSET_SELECTED :
 						       HE_COLORSET_NORMAL);
 	nr_events = convert_unit(nr_events, &unit);
 	printed = snprintf(bf, sizeof(bf), "%lu%c%s%s", nr_events,
 			   unit, unit == ' ' ? "" : " ", ev_name);
 	slsmg_printf("%s", bf);
 	nr_events = evsel->hists.stats.nr_events[PERF_RECORD_LOST];
 	if (nr_events != 0) {
 		menu->lost_events = true;
 		if (!current_entry)
 			ui_browser__set_color(browser, HE_COLORSET_TOP);
 		nr_events = convert_unit(nr_events, &unit);
 		snprintf(bf, sizeof(bf), ": %ld%c%schunks LOST!", nr_events,
 			 unit, unit == ' ' ? "" : " ");
 		warn = bf;
 	}
 	slsmg_write_nstring(warn, browser->width - printed);
 	if (current_entry)
 		menu->selection = evsel;
 }
 static int perf_evsel_menu__run(struct perf_evsel_menu *menu,
 				int nr_events, const char *help,
 				void(*timer)(void *arg), void *arg, int delay_secs)
 {
 	struct perf_evlist *evlist = menu->b.priv;
 	struct perf_evsel *pos;
 	const char *ev_name, *title = "Available samples";
 	int key;
 	if (ui_browser__show(&menu->b, title,
 			     "ESC: exit, ENTER|->: Browse histograms") < 0)
 		return -1;
 	while (1) {
 		key = ui_browser__run(&menu->b, delay_secs);
 		switch (key) {
 		case K_TIMER:
 			timer(arg);
 			if (!menu->lost_events_warned && menu->lost_events) {
 				ui_browser__warn_lost_events(&menu->b);
 				menu->lost_events_warned = true;
 			}
 			continue;
 		case K_RIGHT:
 		case K_ENTER:
 			if (!menu->selection)
 				continue;
 			pos = menu->selection;
 browse_hists:
 			perf_evlist__set_selected(evlist, pos);
 			/*
 			 * Give the calling tool a chance to populate the non
 			 * default evsel resorted hists tree.
 			 */
 			if (timer)
 				timer(arg);
 			ev_name = event_name(pos);
 			key = perf_evsel__hists_browse(pos, nr_events, help,
 						       ev_name, true, timer,
 						       arg, delay_secs);
 			ui_browser__show_title(&menu->b, title);
 			switch (key) {
 			case K_TAB:
 				if (pos->node.next == &evlist->entries)
 					pos = list_entry(evlist->entries.next, struct perf_evsel, node);
 				else
 					pos = list_entry(pos->node.next, struct perf_evsel, node);
 				goto browse_hists;
 			case K_UNTAB:
 				if (pos->node.prev == &evlist->entries)
 					pos = list_entry(evlist->entries.prev, struct perf_evsel, node);
 				else
 					pos = list_entry(pos->node.prev, struct perf_evsel, node);
 				goto browse_hists;
 			case K_ESC:
 				if (!ui_browser__dialog_yesno(&menu->b,
 						"Do you really want to exit?"))
 					continue;
 				/* Fall thru */
 			case 'q':
 			case CTRL('c'):
 				goto out;
 			default:
 				continue;
 			}
 		case K_LEFT:
 			continue;
 		case K_ESC:
 			if (!ui_browser__dialog_yesno(&menu->b,
 					       "Do you really want to exit?"))
 				continue;
 			/* Fall thru */
 		case 'q':
 		case CTRL('c'):
 			goto out;
 		default:
 			continue;
 		}
 	}
 out:
 	ui_browser__hide(&menu->b);
 	return key;
 }
 static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
 					   const char *help,
 					   void(*timer)(void *arg), void *arg,
 					   int delay_secs)
 {
 	struct perf_evsel *pos;
 	struct perf_evsel_menu menu = {
 		.b = {
 			.entries    = &evlist->entries,
 			.refresh    = ui_browser__list_head_refresh,
 			.seek	    = ui_browser__list_head_seek,
 			.write	    = perf_evsel_menu__write,
 			.nr_entries = evlist->nr_entries,
 			.priv	    = evlist,
 		},
 	};
 	ui_helpline__push("Press ESC to exit");
 	list_for_each_entry(pos, &evlist->entries, node) {
 		const char *ev_name = event_name(pos);
 		size_t line_len = strlen(ev_name) + 7;
 		if (menu.b.width < line_len)
 			menu.b.width = line_len;
 		/*
 		 * Cache the evsel name, tracepoints have a _high_ cost per
 		 * event_name() call.
 		 */
 		if (pos->name == NULL)
 			pos->name = strdup(ev_name);
 	}
 	return perf_evsel_menu__run(&menu, evlist->nr_entries, help, timer,
 				    arg, delay_secs);
 }
 int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
 				  void(*timer)(void *arg), void *arg,
 				  int delay_secs)
 {
 	if (evlist->nr_entries == 1) {
 		struct perf_evsel *first = list_entry(evlist->entries.next,
 						      struct perf_evsel, node);
 		const char *ev_name = event_name(first);
 		return perf_evsel__hists_browse(first, evlist->nr_entries, help,
 						ev_name, false, timer, arg,
 						delay_secs);
 	}
 	return __perf_evlist__tui_browse_hists(evlist, help,
 					       timer, arg, delay_secs);
 }

tools/perf/util/ui/helpline.c

Diff comments View file @ 0a84f00

-#define _GNU_SOURCE
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "../debug.h"
 #include "helpline.h"
 #include "ui.h"
 #include "libslang.h"
 void ui_helpline__pop(void)
 {
 }
 char ui_helpline__current[512];
 void ui_helpline__push(const char *msg)
 {
 	const size_t sz = sizeof(ui_helpline__current);
 	SLsmg_gotorc(SLtt_Screen_Rows - 1, 0);
 	SLsmg_set_color(0);
 	SLsmg_write_nstring((char *)msg, SLtt_Screen_Cols);
 	SLsmg_refresh();
 	strncpy(ui_helpline__current, msg, sz)[sz - 1] = '\0';
 }
 void ui_helpline__vpush(const char *fmt, va_list ap)
 {
 	char *s;
 	if (vasprintf(&s, fmt, ap) < 0)
 		vfprintf(stderr, fmt, ap);
 	else {
 		ui_helpline__push(s);
 		free(s);
 	}
 }
 void ui_helpline__fpush(const char *fmt, ...)
 {
 	va_list ap;
 	va_start(ap, fmt);
 	ui_helpline__vpush(fmt, ap);
 	va_end(ap);
 }
 void ui_helpline__puts(const char *msg)
 {
 	ui_helpline__pop();
 	ui_helpline__push(msg);
 }
 void ui_helpline__init(void)
 {
 	ui_helpline__puts(" ");
 }
 char ui_helpline__last_msg[1024];
 int ui_helpline__show_help(const char *format, va_list ap)
 {
 	int ret;
 	static int backlog;
 	pthread_mutex_lock(&ui__lock);
 	ret = vsnprintf(ui_helpline__last_msg + backlog,
 			sizeof(ui_helpline__last_msg) - backlog, format, ap);
 	backlog += ret;
 	if (ui_helpline__last_msg[backlog - 1] == '\n') {
 		ui_helpline__puts(ui_helpline__last_msg);
 		SLsmg_refresh();
 		backlog = 0;
 	}
 	pthread_mutex_unlock(&ui__lock);
 	return ret;
 }

tools/perf/util/util.h

Diff comments View file @ 0a84f00

 #ifndef GIT_COMPAT_UTIL_H
 #define GIT_COMPAT_UTIL_H
 #define _FILE_OFFSET_BITS 64
 #ifndef FLEX_ARRAY
 /*
  * See if our compiler is known to support flexible array members.
  */
 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
 # define FLEX_ARRAY /* empty */
 #elif defined(__GNUC__)
 # if (__GNUC__ >= 3)
 #  define FLEX_ARRAY /* empty */
 # else
 #  define FLEX_ARRAY 0 /* older GNU extension */
 # endif
 #endif
 /*
  * Otherwise, default to safer but a bit wasteful traditional style
  */
 #ifndef FLEX_ARRAY
 # define FLEX_ARRAY 1
 #endif
 #endif
 #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
 #ifdef __GNUC__
 #define TYPEOF(x) (__typeof__(x))
 #else
 #define TYPEOF(x)
 #endif
 #define MSB(x, bits) ((x) & TYPEOF(x)(~0ULL << (sizeof(x) * 8 - (bits))))
 #define HAS_MULTI_BITS(i)  ((i) & ((i) - 1))  /* checks if an integer has more than 1 bit set */
 /* Approximation of the length of the decimal representation of this type. */
 #define decimal_length(x)	((int)(sizeof(x) * 2.56 + 0.5) + 1)
 #define _ALL_SOURCE 1
-#define _GNU_SOURCE 1
 #define _BSD_SOURCE 1
 #define HAS_BOOL
 #include <unistd.h>
 #include <stdio.h>
 #include <sys/stat.h>
 #include <sys/statfs.h>
 #include <fcntl.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
 #include <errno.h>
 #include <limits.h>
 #include <sys/param.h>
 #include <sys/types.h>
 #include <dirent.h>
 #include <sys/time.h>
 #include <time.h>
 #include <signal.h>
 #include <fnmatch.h>
 #include <assert.h>
 #include <regex.h>
 #include <utime.h>
 #include <sys/wait.h>
 #include <sys/poll.h>
 #include <sys/socket.h>
 #include <sys/ioctl.h>
 #include <sys/select.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 #include <arpa/inet.h>
 #include <netdb.h>
 #include <pwd.h>
 #include <inttypes.h>
 #include "../../../include/linux/magic.h"
 #include "types.h"
 #include <sys/ttydefaults.h>
 extern const char *graph_line;
 extern const char *graph_dotted_line;
 extern char buildid_dir[];
 /* On most systems <limits.h> would have given us this, but
  * not on some systems (e.g. GNU/Hurd).
  */
 #ifndef PATH_MAX
 #define PATH_MAX 4096
 #endif
 #ifndef PRIuMAX
 #define PRIuMAX "llu"
 #endif
 #ifndef PRIu32
 #define PRIu32 "u"
 #endif
 #ifndef PRIx32
 #define PRIx32 "x"
 #endif
 #ifndef PATH_SEP
 #define PATH_SEP ':'
 #endif
 #ifndef STRIP_EXTENSION
 #define STRIP_EXTENSION ""
 #endif
 #ifndef has_dos_drive_prefix
 #define has_dos_drive_prefix(path) 0
 #endif
 #ifndef is_dir_sep
 #define is_dir_sep(c) ((c) == '/')
 #endif
 #ifdef __GNUC__
 #define NORETURN __attribute__((__noreturn__))
 #else
 #define NORETURN
 #ifndef __attribute__
 #define __attribute__(x)
 #endif
 #endif
 /* General helper functions */
 extern void usage(const char *err) NORETURN;
 extern void die(const char *err, ...) NORETURN __attribute__((format (printf, 1, 2)));
 extern int error(const char *err, ...) __attribute__((format (printf, 1, 2)));
 extern void warning(const char *err, ...) __attribute__((format (printf, 1, 2)));
 #include "../../../include/linux/stringify.h"
 #define DIE_IF(cnd)	\
 	do { if (cnd)	\
 		die(" at (" __FILE__ ":" __stringify(__LINE__) "): "	\
 		    __stringify(cnd) "\n");				\
 	} while (0)
 extern void set_die_routine(void (*routine)(const char *err, va_list params) NORETURN);
 extern int prefixcmp(const char *str, const char *prefix);
 extern void set_buildid_dir(void);
 extern void disable_buildid_cache(void);
 static inline const char *skip_prefix(const char *str, const char *prefix)
 {
 	size_t len = strlen(prefix);
 	return strncmp(str, prefix, len) ? NULL : str + len;
 }
 #ifdef __GLIBC_PREREQ
 #if __GLIBC_PREREQ(2, 1)
 #define HAVE_STRCHRNUL
 #endif
 #endif
 #ifndef HAVE_STRCHRNUL
 #define strchrnul gitstrchrnul
 static inline char *gitstrchrnul(const char *s, int c)
 {
 	while (*s && *s != c)
 		s++;
 	return (char *)s;
 }
 #endif
 /*
  * Wrappers:
  */
 extern char *xstrdup(const char *str);
 extern void *xrealloc(void *ptr, size_t size) __attribute__((weak));
 static inline void *zalloc(size_t size)
 {
 	return calloc(1, size);
 }
 static inline int has_extension(const char *filename, const char *ext)
 {
 	size_t len = strlen(filename);
 	size_t extlen = strlen(ext);
 	return len > extlen && !memcmp(filename + len - extlen, ext, extlen);
 }
 /* Sane ctype - no locale, and works with signed chars */
 #undef isascii
 #undef isspace
 #undef isdigit
 #undef isxdigit
 #undef isalpha
 #undef isprint
 #undef isalnum
 #undef tolower
 #undef toupper
 extern unsigned char sane_ctype[256];
 #define GIT_SPACE		0x01
 #define GIT_DIGIT		0x02
 #define GIT_ALPHA		0x04
 #define GIT_GLOB_SPECIAL	0x08
 #define GIT_REGEX_SPECIAL	0x10
 #define GIT_PRINT_EXTRA		0x20
 #define GIT_PRINT		0x3E
 #define sane_istest(x,mask) ((sane_ctype[(unsigned char)(x)] & (mask)) != 0)
 #define isascii(x) (((x) & ~0x7f) == 0)
 #define isspace(x) sane_istest(x,GIT_SPACE)
 #define isdigit(x) sane_istest(x,GIT_DIGIT)
 #define isxdigit(x)	\
 	(sane_istest(toupper(x), GIT_ALPHA | GIT_DIGIT) && toupper(x) < 'G')
 #define isalpha(x) sane_istest(x,GIT_ALPHA)
 #define isalnum(x) sane_istest(x,GIT_ALPHA | GIT_DIGIT)
 #define isprint(x) sane_istest(x,GIT_PRINT)
 #define tolower(x) sane_case((unsigned char)(x), 0x20)
 #define toupper(x) sane_case((unsigned char)(x), 0)
 static inline int sane_case(int x, int high)
 {
 	if (sane_istest(x, GIT_ALPHA))
 		x = (x & ~0x20) | high;
 	return x;
 }
 int mkdir_p(char *path, mode_t mode);
 int copyfile(const char *from, const char *to);
 s64 perf_atoll(const char *str);
 char **argv_split(const char *str, int *argcp);
 void argv_free(char **argv);
 bool strglobmatch(const char *str, const char *pat);
 bool strlazymatch(const char *str, const char *pat);
 int strtailcmp(const char *s1, const char *s2);
 unsigned long convert_unit(unsigned long value, char *unit);
 int readn(int fd, void *buf, size_t size);
 struct perf_event_attr;
 void event_attr_init(struct perf_event_attr *attr);
 #define _STR(x) #x
 #define STR(x) _STR(x)
 /*
  *  Determine whether some value is a power of two, where zero is
  * *not* considered a power of two.
  */
 static inline __attribute__((const))
 bool is_power_of_2(unsigned long n)
 {
 	return (n != 0 && ((n & (n - 1)) == 0));
 }
 #endif