Merge branch 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
Linus Torvalds [Wed, 12 Dec 2012 02:14:31 +0000 (18:14 -0800)]
Pull perf updates from Ingo Molnar:
 "Lots of activity:

   211 files changed, 8328 insertions(+), 4116 deletions(-)

  most of it on the tooling side.

  Main changes:

   * ftrace enhancements and fixes from Steve Rostedt.

   * uprobes fixes, cleanups and preparation for the ARM port from Oleg
     Nesterov.

   * UAPI fixes, from David Howels - prepares the arch/x86 UAPI
     transition

   * Separate perf tests into multiple objects, one per test, from Jiri
     Olsa.

   * Make hardware event translations available in sysfs, from Jiri
     Olsa.

   * Fixes to /proc/pid/maps parsing, preparatory to supporting data
     maps, from Namhyung Kim

   * Implement ui_progress for GTK, from Namhyung Kim

   * Add framework for automated perf_event_attr tests, where tools with
     different command line options will be run from a 'perf test', via
     python glue, and the perf syscall will be intercepted to verify
     that the perf_event_attr fields set by the tool are those expected,
     from Jiri Olsa

   * Add a 'link' method for hists, so that we can have the leader with
     buckets for all the entries in all the hists.  This new method is
     now used in the default 'diff' output, making the sum of the
     'baseline' column be 100%, eliminating blind spots.

   * libtraceevent fixes for compiler warnings trying to make perf it
     build on some distros, like fedora 14, 32-bit, some of the warnings
     really pointed to real bugs.

   * Add a browser for 'perf script' and make it available from the
     report and annotate browsers.  It does filtering to find the
     scripts that handle events found in the perf.data file used.  From
     Feng Tang

   * perf inject changes to allow showing where a task sleeps, from
     Andrew Vagin.

   * Makefile improvements from Namhyung Kim.

   * Add --pre and --post command hooks in 'stat', from Peter Zijlstra.

   * Don't stop synthesizing threads when one vanishes, this is for the
     existing threads when we start a tool like trace.

   * Use sched:sched_stat_runtime to provide a thread summary, this
     produces the same output as the 'trace summary' subcommand of
     tglx's original "trace" tool.

   * Support interrupted syscalls in 'trace'

   * Add an event duration column and filter in 'trace'.

   * There are references to the man pages in some tools, so try to
     build Documentation when installing, warning the user if that is
     not possible, from Borislav Petkov.

   * Give user better message if precise is not supported, from David
     Ahern.

   * Try to find cross-built objdump path by using the session
     environment information in the perf.data file header, from Irina
     Tirdea, original patch and idea by Namhyung Kim.

   * Diplays more output on features check for make V=1, so that one can
     figure out what is happening by looking at gcc output, etc.  From
     Jiri Olsa.

   * Add on_exit implementation for systems without one, e.g.  Android,
     from Bernhard Rosenkraenzer.

   * Only process events for vcpus of interest, helps handling large
     number of events, from David Ahern.

   * Cross compilation fixes for Android, from Irina Tirdea.

   * Add documentation on compiling for Android, from Irina Tirdea.

   * perf diff improvements from Jiri Olsa.

   * Target (task/user/cpu/syswide) handling improvements, from Namhyung
     Kim.

   * Add support in 'trace' for tracing workload given by command line,
     from Namhyung Kim.

   * ... and much more."

* 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (194 commits)
  uprobes: Use percpu_rw_semaphore to fix register/unregister vs dup_mmap() race
  perf evsel: Introduce is_group_member method
  perf powerpc: Use uapi/unistd.h to fix build error
  tools: Pass the target in descend
  tools: Honour the O= flag when tool build called from a higher Makefile
  tools: Define a Makefile function to do subdir processing
  perf ui: Always compile browser setup code
  perf ui: Add ui_progress__finish()
  perf ui gtk: Implement ui_progress functions
  perf ui: Introduce generic ui_progress helper
  perf ui tui: Move progress.c under ui/tui directory
  perf tools: Add basic event modifier sanity check
  perf tools: Omit group members from perf_evlist__disable/enable
  perf tools: Ensure single disable call per event in record comand
  perf tools: Fix 'disabled' attribute config for record command
  perf tools: Fix attributes for '{}' defined event groups
  perf tools: Use sscanf for parsing /proc/pid/maps
  perf tools: Add gtk.<command> config option for launching GTK browser
  perf tools: Fix compile error on NO_NEWT=1 build
  perf hists: Initialize all of he->stat with zeroes
  ...

211 files changed:
Documentation/kernel-parameters.txt
arch/alpha/include/asm/Kbuild
arch/arm/include/asm/Kbuild
arch/arm64/include/asm/Kbuild
arch/avr32/include/asm/Kbuild
arch/blackfin/include/asm/Kbuild
arch/c6x/include/asm/Kbuild
arch/cris/include/asm/Kbuild
arch/frv/include/asm/Kbuild
arch/h8300/include/asm/Kbuild
arch/hexagon/include/asm/Kbuild
arch/ia64/include/asm/Kbuild
arch/m32r/include/asm/Kbuild
arch/m68k/include/asm/Kbuild
arch/microblaze/include/asm/Kbuild
arch/mips/include/asm/Kbuild
arch/mn10300/include/asm/Kbuild
arch/openrisc/include/asm/Kbuild
arch/parisc/include/asm/Kbuild
arch/powerpc/include/asm/Kbuild
arch/powerpc/kernel/signal.c
arch/powerpc/kernel/uprobes.c
arch/s390/include/asm/Kbuild
arch/score/include/asm/Kbuild
arch/sh/include/asm/Kbuild
arch/sparc/include/asm/Kbuild
arch/tile/include/asm/Kbuild
arch/um/include/asm/Kbuild
arch/unicore32/include/asm/Kbuild
arch/x86/include/asm/trace_clock.h [new file with mode: 0644]
arch/x86/kernel/Makefile
arch/x86/kernel/cpu/perf_event.c
arch/x86/kernel/cpu/perf_event.h
arch/x86/kernel/cpu/perf_event_amd.c
arch/x86/kernel/cpu/perf_event_intel.c
arch/x86/kernel/cpu/perf_event_p6.c
arch/x86/kernel/rtc.c
arch/x86/kernel/trace_clock.c [new file with mode: 0644]
arch/x86/kernel/tsc.c
arch/x86/kernel/uprobes.c
arch/xtensa/include/asm/Kbuild
include/asm-generic/trace_clock.h [new file with mode: 0644]
include/linux/ftrace_event.h
include/linux/kernel.h
include/linux/ring_buffer.h
include/linux/trace_clock.h
include/linux/uprobes.h
include/trace/ftrace.h
include/trace/syscall.h
kernel/events/uprobes.c
kernel/fork.c
kernel/trace/Kconfig
kernel/trace/ftrace.c
kernel/trace/ring_buffer.c
kernel/trace/trace.c
kernel/trace/trace.h
kernel/trace/trace_branch.c
kernel/trace/trace_events.c
kernel/trace/trace_events_filter.c
kernel/trace/trace_functions.c
kernel/trace/trace_functions_graph.c
kernel/trace/trace_irqsoff.c
kernel/trace/trace_kprobe.c
kernel/trace/trace_output.c
kernel/trace/trace_probe.c
kernel/trace/trace_sched_switch.c
kernel/trace/trace_sched_wakeup.c
kernel/trace/trace_selftest.c
kernel/trace/trace_syscalls.c
kernel/trace/trace_uprobe.c
tools/lib/traceevent/Makefile
tools/lib/traceevent/event-parse.c
tools/perf/Documentation/Makefile
tools/perf/Documentation/android.txt [new file with mode: 0644]
tools/perf/Documentation/perf-diff.txt
tools/perf/Documentation/perf-inject.txt
tools/perf/Documentation/perf-stat.txt
tools/perf/Documentation/perf-trace.txt
tools/perf/Makefile
tools/perf/arch/common.c [new file with mode: 0644]
tools/perf/arch/common.h [new file with mode: 0644]
tools/perf/builtin-annotate.c
tools/perf/builtin-buildid-cache.c
tools/perf/builtin-buildid-list.c
tools/perf/builtin-diff.c
tools/perf/builtin-evlist.c
tools/perf/builtin-inject.c
tools/perf/builtin-kmem.c
tools/perf/builtin-kvm.c
tools/perf/builtin-lock.c
tools/perf/builtin-record.c
tools/perf/builtin-report.c
tools/perf/builtin-sched.c
tools/perf/builtin-script.c
tools/perf/builtin-stat.c
tools/perf/builtin-test.c [deleted file]
tools/perf/builtin-timechart.c
tools/perf/builtin-top.c
tools/perf/builtin-trace.c
tools/perf/config/feature-tests.mak
tools/perf/config/utilities.mak
tools/perf/perf.c
tools/perf/perf.h
tools/perf/tests/attr.c [new file with mode: 0644]
tools/perf/tests/attr.py [new file with mode: 0644]
tools/perf/tests/attr/README [new file with mode: 0644]
tools/perf/tests/attr/base-record [new file with mode: 0644]
tools/perf/tests/attr/base-stat [new file with mode: 0644]
tools/perf/tests/attr/test-record-basic [new file with mode: 0644]
tools/perf/tests/attr/test-record-branch-any [new file with mode: 0644]
tools/perf/tests/attr/test-record-branch-filter-any [new file with mode: 0644]
tools/perf/tests/attr/test-record-branch-filter-any_call [new file with mode: 0644]
tools/perf/tests/attr/test-record-branch-filter-any_ret [new file with mode: 0644]
tools/perf/tests/attr/test-record-branch-filter-hv [new file with mode: 0644]
tools/perf/tests/attr/test-record-branch-filter-ind_call [new file with mode: 0644]
tools/perf/tests/attr/test-record-branch-filter-k [new file with mode: 0644]
tools/perf/tests/attr/test-record-branch-filter-u [new file with mode: 0644]
tools/perf/tests/attr/test-record-count [new file with mode: 0644]
tools/perf/tests/attr/test-record-data [new file with mode: 0644]
tools/perf/tests/attr/test-record-freq [new file with mode: 0644]
tools/perf/tests/attr/test-record-graph-default [new file with mode: 0644]
tools/perf/tests/attr/test-record-graph-dwarf [new file with mode: 0644]
tools/perf/tests/attr/test-record-graph-fp [new file with mode: 0644]
tools/perf/tests/attr/test-record-group [new file with mode: 0644]
tools/perf/tests/attr/test-record-group1 [new file with mode: 0644]
tools/perf/tests/attr/test-record-no-delay [new file with mode: 0644]
tools/perf/tests/attr/test-record-no-inherit [new file with mode: 0644]
tools/perf/tests/attr/test-record-no-samples [new file with mode: 0644]
tools/perf/tests/attr/test-record-period [new file with mode: 0644]
tools/perf/tests/attr/test-record-raw [new file with mode: 0644]
tools/perf/tests/attr/test-stat-basic [new file with mode: 0644]
tools/perf/tests/attr/test-stat-default [new file with mode: 0644]
tools/perf/tests/attr/test-stat-detailed-1 [new file with mode: 0644]
tools/perf/tests/attr/test-stat-detailed-2 [new file with mode: 0644]
tools/perf/tests/attr/test-stat-detailed-3 [new file with mode: 0644]
tools/perf/tests/attr/test-stat-group [new file with mode: 0644]
tools/perf/tests/attr/test-stat-group1 [new file with mode: 0644]
tools/perf/tests/attr/test-stat-no-inherit [new file with mode: 0644]
tools/perf/tests/builtin-test.c [new file with mode: 0644]
tools/perf/tests/dso-data.c [moved from tools/perf/util/dso-test-data.c with 95% similarity]
tools/perf/tests/evsel-roundtrip-name.c [new file with mode: 0644]
tools/perf/tests/evsel-tp-sched.c [new file with mode: 0644]
tools/perf/tests/mmap-basic.c [new file with mode: 0644]
tools/perf/tests/open-syscall-all-cpus.c [new file with mode: 0644]
tools/perf/tests/open-syscall-tp-fields.c [new file with mode: 0644]
tools/perf/tests/open-syscall.c [new file with mode: 0644]
tools/perf/tests/parse-events.c [moved from tools/perf/util/parse-events-test.c with 94% similarity]
tools/perf/tests/perf-record.c [new file with mode: 0644]
tools/perf/tests/pmu.c [new file with mode: 0644]
tools/perf/tests/rdpmc.c [new file with mode: 0644]
tools/perf/tests/tests.h [new file with mode: 0644]
tools/perf/tests/util.c [new file with mode: 0644]
tools/perf/tests/vmlinux-kallsyms.c [new file with mode: 0644]
tools/perf/ui/browsers/annotate.c
tools/perf/ui/browsers/hists.c
tools/perf/ui/browsers/scripts.c [new file with mode: 0644]
tools/perf/ui/gtk/browser.c
tools/perf/ui/gtk/gtk.h
tools/perf/ui/gtk/progress.c [new file with mode: 0644]
tools/perf/ui/gtk/setup.c
tools/perf/ui/gtk/util.c
tools/perf/ui/hist.c
tools/perf/ui/progress.c
tools/perf/ui/progress.h
tools/perf/ui/stdio/hist.c
tools/perf/ui/tui/progress.c [new file with mode: 0644]
tools/perf/ui/tui/setup.c
tools/perf/ui/ui.h
tools/perf/util/PERF-VERSION-GEN
tools/perf/util/annotate.c
tools/perf/util/annotate.h
tools/perf/util/build-id.c
tools/perf/util/build-id.h
tools/perf/util/cache.h
tools/perf/util/debug.h
tools/perf/util/dso.c [new file with mode: 0644]
tools/perf/util/dso.h [new file with mode: 0644]
tools/perf/util/event.c
tools/perf/util/event.h
tools/perf/util/evlist.c
tools/perf/util/evsel.c
tools/perf/util/evsel.h
tools/perf/util/header.c
tools/perf/util/header.h
tools/perf/util/hist.c
tools/perf/util/hist.h
tools/perf/util/machine.c [new file with mode: 0644]
tools/perf/util/machine.h [new file with mode: 0644]
tools/perf/util/map.c
tools/perf/util/map.h
tools/perf/util/parse-events.c
tools/perf/util/parse-events.h
tools/perf/util/parse-events.l
tools/perf/util/parse-events.y
tools/perf/util/pmu.c
tools/perf/util/pmu.h
tools/perf/util/pstack.c
tools/perf/util/python.c
tools/perf/util/rblist.c
tools/perf/util/scripting-engines/trace-event-python.c
tools/perf/util/session.c
tools/perf/util/session.h
tools/perf/util/sort.h
tools/perf/util/string.c
tools/perf/util/symbol.c
tools/perf/util/symbol.h
tools/perf/util/thread.c
tools/perf/util/thread.h
tools/perf/util/trace-event-read.c
tools/perf/util/util.c
tools/perf/util/util.h

index 9d2e5cb..03d1251 100644 (file)
@@ -2880,6 +2880,22 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
                        to facilitate early boot debugging.
                        See also Documentation/trace/events.txt
 
+       trace_options=[option-list]
+                       [FTRACE] Enable or disable tracer options at boot.
+                       The option-list is a comma delimited list of options
+                       that can be enabled or disabled just as if you were
+                       to echo the option name into
+
+                           /sys/kernel/debug/tracing/trace_options
+
+                       For example, to enable stacktrace option (to dump the
+                       stack trace of each event), add to the command line:
+
+                             trace_options=stacktrace
+
+                       See also Documentation/trace/ftrace.txt "trace options"
+                       section.
+
        transparent_hugepage=
                        [KNL]
                        Format: [always|madvise|never]
index 64ffc9e..dcfabb9 100644 (file)
@@ -11,3 +11,4 @@ header-y += reg.h
 header-y += regdef.h
 header-y += sysinfo.h
 generic-y += exec.h
+generic-y += trace_clock.h
index f70ae17..514e398 100644 (file)
@@ -31,5 +31,6 @@ generic-y += sockios.h
 generic-y += termbits.h
 generic-y += termios.h
 generic-y += timex.h
+generic-y += trace_clock.h
 generic-y += types.h
 generic-y += unaligned.h
index a581a22..6e9ca46 100644 (file)
@@ -43,6 +43,7 @@ generic-y += swab.h
 generic-y += termbits.h
 generic-y += termios.h
 generic-y += topology.h
+generic-y += trace_clock.h
 generic-y += types.h
 generic-y += unaligned.h
 generic-y += user.h
index 4807ded..4dd4f78 100644 (file)
@@ -1,3 +1,4 @@
 
 generic-y      += clkdev.h
 generic-y      += exec.h
+generic-y      += trace_clock.h
index 5a0625a..27d7075 100644 (file)
@@ -38,6 +38,7 @@ generic-y += statfs.h
 generic-y += termbits.h
 generic-y += termios.h
 generic-y += topology.h
+generic-y += trace_clock.h
 generic-y += types.h
 generic-y += ucontext.h
 generic-y += unaligned.h
index 112a496..eae7b59 100644 (file)
@@ -49,6 +49,7 @@ generic-y += termbits.h
 generic-y += termios.h
 generic-y += tlbflush.h
 generic-y += topology.h
+generic-y += trace_clock.h
 generic-y += types.h
 generic-y += ucontext.h
 generic-y += user.h
index 6d43a95..15a122c 100644 (file)
@@ -11,3 +11,4 @@ header-y += sync_serial.h
 generic-y += clkdev.h
 generic-y += exec.h
 generic-y += module.h
+generic-y += trace_clock.h
index 4a159da..c5d7670 100644 (file)
@@ -1,3 +1,4 @@
 
 generic-y += clkdev.h
 generic-y += exec.h
+generic-y += trace_clock.h
index 50bbf38..4bc8ae7 100644 (file)
@@ -3,3 +3,4 @@ include include/asm-generic/Kbuild.asm
 generic-y += clkdev.h
 generic-y += exec.h
 generic-y += module.h
+generic-y += trace_clock.h
index 3bfa9b3..bdb54ce 100644 (file)
@@ -48,6 +48,7 @@ generic-y += stat.h
 generic-y += termbits.h
 generic-y += termios.h
 generic-y += topology.h
+generic-y += trace_clock.h
 generic-y += types.h
 generic-y += ucontext.h
 generic-y += unaligned.h
index dd02f09..05b03ec 100644 (file)
@@ -2,3 +2,4 @@
 generic-y += clkdev.h
 generic-y += exec.h
 generic-y += kvm_para.h
+generic-y += trace_clock.h
index 50bbf38..4bc8ae7 100644 (file)
@@ -3,3 +3,4 @@ include include/asm-generic/Kbuild.asm
 generic-y += clkdev.h
 generic-y += exec.h
 generic-y += module.h
+generic-y += trace_clock.h
index 88fa3ac..7f1949c 100644 (file)
@@ -24,6 +24,7 @@ generic-y += sections.h
 generic-y += siginfo.h
 generic-y += statfs.h
 generic-y += topology.h
+generic-y += trace_clock.h
 generic-y += types.h
 generic-y += word-at-a-time.h
 generic-y += xor.h
index 8653072..2957fcc 100644 (file)
@@ -3,3 +3,4 @@ include include/asm-generic/Kbuild.asm
 header-y  += elf.h
 generic-y += clkdev.h
 generic-y += exec.h
+generic-y += trace_clock.h
index 533053d..9b54b7a 100644 (file)
@@ -1 +1,2 @@
 # MIPS headers
+generic-y += trace_clock.h
index 4a159da..c5d7670 100644 (file)
@@ -1,3 +1,4 @@
 
 generic-y += clkdev.h
 generic-y += exec.h
+generic-y += trace_clock.h
index 78de680..8971026 100644 (file)
@@ -60,6 +60,7 @@ generic-y += swab.h
 generic-y += termbits.h
 generic-y += termios.h
 generic-y += topology.h
+generic-y += trace_clock.h
 generic-y += types.h
 generic-y += ucontext.h
 generic-y += user.h
index bac8deb..ff4c9fa 100644 (file)
@@ -3,3 +3,4 @@ generic-y += word-at-a-time.h auxvec.h user.h cputime.h emergency-restart.h \
          segment.h topology.h vga.h device.h percpu.h hw_irq.h mutex.h \
          div64.h irq_regs.h kdebug.h kvm_para.h local64.h local.h param.h \
          poll.h xor.h clkdev.h exec.h
+generic-y += trace_clock.h
index a4fe15e..2d62b48 100644 (file)
@@ -2,3 +2,4 @@
 
 generic-y += clkdev.h
 generic-y += rwsem.h
+generic-y += trace_clock.h
index a2dc757..3b99711 100644 (file)
@@ -158,10 +158,8 @@ static int do_signal(struct pt_regs *regs)
 
 void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
 {
-       if (thread_info_flags & _TIF_UPROBE) {
-               clear_thread_flag(TIF_UPROBE);
+       if (thread_info_flags & _TIF_UPROBE)
                uprobe_notify_resume(regs);
-       }
 
        if (thread_info_flags & _TIF_SIGPENDING)
                do_signal(regs);
index d2d46d1..bc77834 100644 (file)
@@ -64,6 +64,8 @@ int arch_uprobe_pre_xol(struct arch_uprobe *auprobe, struct pt_regs *regs)
        autask->saved_trap_nr = current->thread.trap_nr;
        current->thread.trap_nr = UPROBE_TRAP_NR;
        regs->nip = current->utask->xol_vaddr;
+
+       user_enable_single_step(current);
        return 0;
 }
 
@@ -119,6 +121,8 @@ int arch_uprobe_post_xol(struct arch_uprobe *auprobe, struct pt_regs *regs)
         * to be executed.
         */
        regs->nip = utask->vaddr + MAX_UINSN_BYTES;
+
+       user_disable_single_step(current);
        return 0;
 }
 
@@ -162,6 +166,8 @@ void arch_uprobe_abort_xol(struct arch_uprobe *auprobe, struct pt_regs *regs)
 
        current->thread.trap_nr = utask->autask.saved_trap_nr;
        instruction_pointer_set(regs, utask->vaddr);
+
+       user_disable_single_step(current);
 }
 
 /*
index 0633dc6..f313f9c 100644 (file)
@@ -1,3 +1,4 @@
 
 
 generic-y += clkdev.h
+generic-y += trace_clock.h
index ec697ae..16e41fe 100644 (file)
@@ -3,3 +3,4 @@ include include/asm-generic/Kbuild.asm
 header-y +=
 
 generic-y += clkdev.h
+generic-y += trace_clock.h
index 29f83be..280bea9 100644 (file)
@@ -31,5 +31,6 @@ generic-y += socket.h
 generic-y += statfs.h
 generic-y += termbits.h
 generic-y += termios.h
+generic-y += trace_clock.h
 generic-y += ucontext.h
 generic-y += xor.h
index 645a58d..e26d430 100644 (file)
@@ -8,4 +8,5 @@ generic-y += local64.h
 generic-y += irq_regs.h
 generic-y += local.h
 generic-y += module.h
+generic-y += trace_clock.h
 generic-y += word-at-a-time.h
index 6948015..b17b9b8 100644 (file)
@@ -34,5 +34,6 @@ generic-y += sockios.h
 generic-y += statfs.h
 generic-y += termbits.h
 generic-y += termios.h
+generic-y += trace_clock.h
 generic-y += types.h
 generic-y += xor.h
index 0f6e7b3..b30f34a 100644 (file)
@@ -2,3 +2,4 @@ generic-y += bug.h cputime.h device.h emergency-restart.h futex.h hardirq.h
 generic-y += hw_irq.h irq_regs.h kdebug.h percpu.h sections.h topology.h xor.h
 generic-y += ftrace.h pci.h io.h param.h delay.h mutex.h current.h exec.h
 generic-y += switch_to.h clkdev.h
+generic-y += trace_clock.h
index 601e92f..89d8b6c 100644 (file)
@@ -53,6 +53,7 @@ generic-y += syscalls.h
 generic-y += termbits.h
 generic-y += termios.h
 generic-y += topology.h
+generic-y += trace_clock.h
 generic-y += types.h
 generic-y += ucontext.h
 generic-y += unaligned.h
diff --git a/arch/x86/include/asm/trace_clock.h b/arch/x86/include/asm/trace_clock.h
new file mode 100644 (file)
index 0000000..beab86c
--- /dev/null
@@ -0,0 +1,20 @@
+#ifndef _ASM_X86_TRACE_CLOCK_H
+#define _ASM_X86_TRACE_CLOCK_H
+
+#include <linux/compiler.h>
+#include <linux/types.h>
+
+#ifdef CONFIG_X86_TSC
+
+extern u64 notrace trace_clock_x86_tsc(void);
+
+# define ARCH_TRACE_CLOCKS \
+       { trace_clock_x86_tsc,  "x86-tsc",      .in_ns = 0 },
+
+#else /* !CONFIG_X86_TSC */
+
+#define ARCH_TRACE_CLOCKS
+
+#endif
+
+#endif  /* _ASM_X86_TRACE_CLOCK_H */
index 91ce48f..34e923a 100644 (file)
@@ -9,7 +9,6 @@ CPPFLAGS_vmlinux.lds += -U$(UTS_MACHINE)
 ifdef CONFIG_FUNCTION_TRACER
 # Do not profile debug and lowlevel utilities
 CFLAGS_REMOVE_tsc.o = -pg
-CFLAGS_REMOVE_rtc.o = -pg
 CFLAGS_REMOVE_paravirt-spinlocks.o = -pg
 CFLAGS_REMOVE_pvclock.o = -pg
 CFLAGS_REMOVE_kvmclock.o = -pg
@@ -62,6 +61,7 @@ obj-$(CONFIG_X86_REBOOTFIXUPS)        += reboot_fixups_32.o
 obj-$(CONFIG_DYNAMIC_FTRACE)   += ftrace.o
 obj-$(CONFIG_FUNCTION_GRAPH_TRACER) += ftrace.o
 obj-$(CONFIG_FTRACE_SYSCALLS)  += ftrace.o
+obj-$(CONFIG_X86_TSC)          += trace_clock.o
 obj-$(CONFIG_KEXEC)            += machine_kexec_$(BITS).o
 obj-$(CONFIG_KEXEC)            += relocate_kernel_$(BITS).o crash.o
 obj-$(CONFIG_CRASH_DUMP)       += crash_dump_$(BITS).o
index 4a3374e..4428fd1 100644 (file)
@@ -1316,6 +1316,121 @@ static struct attribute_group x86_pmu_format_group = {
        .attrs = NULL,
 };
 
+struct perf_pmu_events_attr {
+       struct device_attribute attr;
+       u64 id;
+};
+
+/*
+ * Remove all undefined events (x86_pmu.event_map(id) == 0)
+ * out of events_attr attributes.
+ */
+static void __init filter_events(struct attribute **attrs)
+{
+       int i, j;
+
+       for (i = 0; attrs[i]; i++) {
+               if (x86_pmu.event_map(i))
+                       continue;
+
+               for (j = i; attrs[j]; j++)
+                       attrs[j] = attrs[j + 1];
+
+               /* Check the shifted attr. */
+               i--;
+       }
+}
+
+static ssize_t events_sysfs_show(struct device *dev, struct device_attribute *attr,
+                         char *page)
+{
+       struct perf_pmu_events_attr *pmu_attr = \
+               container_of(attr, struct perf_pmu_events_attr, attr);
+
+       u64 config = x86_pmu.event_map(pmu_attr->id);
+       return x86_pmu.events_sysfs_show(page, config);
+}
+
+#define EVENT_VAR(_id)  event_attr_##_id
+#define EVENT_PTR(_id) &event_attr_##_id.attr.attr
+
+#define EVENT_ATTR(_name, _id)                                 \
+static struct perf_pmu_events_attr EVENT_VAR(_id) = {          \
+       .attr = __ATTR(_name, 0444, events_sysfs_show, NULL),   \
+       .id   =  PERF_COUNT_HW_##_id,                           \
+};
+
+EVENT_ATTR(cpu-cycles,                 CPU_CYCLES              );
+EVENT_ATTR(instructions,               INSTRUCTIONS            );
+EVENT_ATTR(cache-references,           CACHE_REFERENCES        );
+EVENT_ATTR(cache-misses,               CACHE_MISSES            );
+EVENT_ATTR(branch-instructions,                BRANCH_INSTRUCTIONS     );
+EVENT_ATTR(branch-misses,              BRANCH_MISSES           );
+EVENT_ATTR(bus-cycles,                 BUS_CYCLES              );
+EVENT_ATTR(stalled-cycles-frontend,    STALLED_CYCLES_FRONTEND );
+EVENT_ATTR(stalled-cycles-backend,     STALLED_CYCLES_BACKEND  );
+EVENT_ATTR(ref-cycles,                 REF_CPU_CYCLES          );
+
+static struct attribute *empty_attrs;
+
+static struct attribute *events_attr[] = {
+       EVENT_PTR(CPU_CYCLES),
+       EVENT_PTR(INSTRUCTIONS),
+       EVENT_PTR(CACHE_REFERENCES),
+       EVENT_PTR(CACHE_MISSES),
+       EVENT_PTR(BRANCH_INSTRUCTIONS),
+       EVENT_PTR(BRANCH_MISSES),
+       EVENT_PTR(BUS_CYCLES),
+       EVENT_PTR(STALLED_CYCLES_FRONTEND),
+       EVENT_PTR(STALLED_CYCLES_BACKEND),
+       EVENT_PTR(REF_CPU_CYCLES),
+       NULL,
+};
+
+static struct attribute_group x86_pmu_events_group = {
+       .name = "events",
+       .attrs = events_attr,
+};
+
+ssize_t x86_event_sysfs_show(char *page, u64 config, u64 event)
+{
+       u64 umask  = (config & ARCH_PERFMON_EVENTSEL_UMASK) >> 8;
+       u64 cmask  = (config & ARCH_PERFMON_EVENTSEL_CMASK) >> 24;
+       bool edge  = (config & ARCH_PERFMON_EVENTSEL_EDGE);
+       bool pc    = (config & ARCH_PERFMON_EVENTSEL_PIN_CONTROL);
+       bool any   = (config & ARCH_PERFMON_EVENTSEL_ANY);
+       bool inv   = (config & ARCH_PERFMON_EVENTSEL_INV);
+       ssize_t ret;
+
+       /*
+       * We have whole page size to spend and just little data
+       * to write, so we can safely use sprintf.
+       */
+       ret = sprintf(page, "event=0x%02llx", event);
+
+       if (umask)
+               ret += sprintf(page + ret, ",umask=0x%02llx", umask);
+
+       if (edge)
+               ret += sprintf(page + ret, ",edge");
+
+       if (pc)
+               ret += sprintf(page + ret, ",pc");
+
+       if (any)
+               ret += sprintf(page + ret, ",any");
+
+       if (inv)
+               ret += sprintf(page + ret, ",inv");
+
+       if (cmask)
+               ret += sprintf(page + ret, ",cmask=0x%02llx", cmask);
+
+       ret += sprintf(page + ret, "\n");
+
+       return ret;
+}
+
 static int __init init_hw_perf_events(void)
 {
        struct x86_pmu_quirk *quirk;
@@ -1362,6 +1477,11 @@ static int __init init_hw_perf_events(void)
        x86_pmu.attr_rdpmc = 1; /* enable userspace RDPMC usage by default */
        x86_pmu_format_group.attrs = x86_pmu.format_attrs;
 
+       if (!x86_pmu.events_sysfs_show)
+               x86_pmu_events_group.attrs = &empty_attrs;
+       else
+               filter_events(x86_pmu_events_group.attrs);
+
        pr_info("... version:                %d\n",     x86_pmu.version);
        pr_info("... bit width:              %d\n",     x86_pmu.cntval_bits);
        pr_info("... generic registers:      %d\n",     x86_pmu.num_counters);
@@ -1651,6 +1771,7 @@ static struct attribute_group x86_pmu_attr_group = {
 static const struct attribute_group *x86_pmu_attr_groups[] = {
        &x86_pmu_attr_group,
        &x86_pmu_format_group,
+       &x86_pmu_events_group,
        NULL,
 };
 
index 271d257..115c1ea 100644 (file)
@@ -354,6 +354,8 @@ struct x86_pmu {
        int             attr_rdpmc;
        struct attribute **format_attrs;
 
+       ssize_t         (*events_sysfs_show)(char *page, u64 config);
+
        /*
         * CPU Hotplug hooks
         */
@@ -536,6 +538,9 @@ static inline void set_linear_ip(struct pt_regs *regs, unsigned long ip)
        regs->ip = ip;
 }
 
+ssize_t x86_event_sysfs_show(char *page, u64 config, u64 event);
+ssize_t intel_event_sysfs_show(char *page, u64 config);
+
 #ifdef CONFIG_CPU_SUP_AMD
 
 int amd_pmu_init(void);
index 4528ae7..c93bc4e 100644 (file)
@@ -568,6 +568,14 @@ amd_get_event_constraints_f15h(struct cpu_hw_events *cpuc, struct perf_event *ev
        }
 }
 
+static ssize_t amd_event_sysfs_show(char *page, u64 config)
+{
+       u64 event = (config & ARCH_PERFMON_EVENTSEL_EVENT) |
+                   (config & AMD64_EVENTSEL_EVENT) >> 24;
+
+       return x86_event_sysfs_show(page, config, event);
+}
+
 static __initconst const struct x86_pmu amd_pmu = {
        .name                   = "AMD",
        .handle_irq             = x86_pmu_handle_irq,
@@ -591,6 +599,7 @@ static __initconst const struct x86_pmu amd_pmu = {
        .put_event_constraints  = amd_put_event_constraints,
 
        .format_attrs           = amd_format_attr,
+       .events_sysfs_show      = amd_event_sysfs_show,
 
        .cpu_prepare            = amd_pmu_cpu_prepare,
        .cpu_starting           = amd_pmu_cpu_starting,
index 324bb52..93b9e11 100644 (file)
@@ -1603,6 +1603,13 @@ static struct attribute *intel_arch_formats_attr[] = {
        NULL,
 };
 
+ssize_t intel_event_sysfs_show(char *page, u64 config)
+{
+       u64 event = (config & ARCH_PERFMON_EVENTSEL_EVENT);
+
+       return x86_event_sysfs_show(page, config, event);
+}
+
 static __initconst const struct x86_pmu core_pmu = {
        .name                   = "core",
        .handle_irq             = x86_pmu_handle_irq,
@@ -1628,6 +1635,7 @@ static __initconst const struct x86_pmu core_pmu = {
        .event_constraints      = intel_core_event_constraints,
        .guest_get_msrs         = core_guest_get_msrs,
        .format_attrs           = intel_arch_formats_attr,
+       .events_sysfs_show      = intel_event_sysfs_show,
 };
 
 struct intel_shared_regs *allocate_shared_regs(int cpu)
@@ -1766,6 +1774,7 @@ static __initconst const struct x86_pmu intel_pmu = {
        .pebs_aliases           = intel_pebs_aliases_core2,
 
        .format_attrs           = intel_arch3_formats_attr,
+       .events_sysfs_show      = intel_event_sysfs_show,
 
        .cpu_prepare            = intel_pmu_cpu_prepare,
        .cpu_starting           = intel_pmu_cpu_starting,
index 7d0270b..f2af39f 100644 (file)
@@ -227,6 +227,8 @@ static __initconst const struct x86_pmu p6_pmu = {
        .event_constraints      = p6_event_constraints,
 
        .format_attrs           = intel_p6_formats_attr,
+       .events_sysfs_show      = intel_event_sysfs_show,
+
 };
 
 __init int p6_pmu_init(void)
index 4929c1b..801602b 100644 (file)
@@ -195,12 +195,6 @@ void read_persistent_clock(struct timespec *ts)
        ts->tv_nsec = 0;
 }
 
-unsigned long long native_read_tsc(void)
-{
-       return __native_read_tsc();
-}
-EXPORT_SYMBOL(native_read_tsc);
-
 
 static struct resource rtc_resources[] = {
        [0] = {
diff --git a/arch/x86/kernel/trace_clock.c b/arch/x86/kernel/trace_clock.c
new file mode 100644 (file)
index 0000000..25b9937
--- /dev/null
@@ -0,0 +1,21 @@
+/*
+ * X86 trace clocks
+ */
+#include <asm/trace_clock.h>
+#include <asm/barrier.h>
+#include <asm/msr.h>
+
+/*
+ * trace_clock_x86_tsc(): A clock that is just the cycle counter.
+ *
+ * Unlike the other clocks, this is not in nanoseconds.
+ */
+u64 notrace trace_clock_x86_tsc(void)
+{
+       u64 ret;
+
+       rdtsc_barrier();
+       rdtscll(ret);
+
+       return ret;
+}
index cfa5d4f..06ccb50 100644 (file)
@@ -77,6 +77,12 @@ unsigned long long
 sched_clock(void) __attribute__((alias("native_sched_clock")));
 #endif
 
+unsigned long long native_read_tsc(void)
+{
+       return __native_read_tsc();
+}
+EXPORT_SYMBOL(native_read_tsc);
+
 int check_tsc_unstable(void)
 {
        return tsc_unstable;
index aafa555..c71025b 100644 (file)
@@ -478,6 +478,11 @@ int arch_uprobe_pre_xol(struct arch_uprobe *auprobe, struct pt_regs *regs)
        regs->ip = current->utask->xol_vaddr;
        pre_xol_rip_insn(auprobe, regs, autask);
 
+       autask->saved_tf = !!(regs->flags & X86_EFLAGS_TF);
+       regs->flags |= X86_EFLAGS_TF;
+       if (test_tsk_thread_flag(current, TIF_BLOCKSTEP))
+               set_task_blockstep(current, false);
+
        return 0;
 }
 
@@ -603,6 +608,16 @@ int arch_uprobe_post_xol(struct arch_uprobe *auprobe, struct pt_regs *regs)
        if (auprobe->fixups & UPROBE_FIX_CALL)
                result = adjust_ret_addr(regs->sp, correction);
 
+       /*
+        * arch_uprobe_pre_xol() doesn't save the state of TIF_BLOCKSTEP
+        * so we can get an extra SIGTRAP if we do not clear TF. We need
+        * to examine the opcode to make it right.
+        */
+       if (utask->autask.saved_tf)
+               send_sig(SIGTRAP, current, 0);
+       else if (!(auprobe->fixups & UPROBE_FIX_SETF))
+               regs->flags &= ~X86_EFLAGS_TF;
+
        return result;
 }
 
@@ -647,6 +662,10 @@ void arch_uprobe_abort_xol(struct arch_uprobe *auprobe, struct pt_regs *regs)
        current->thread.trap_nr = utask->autask.saved_trap_nr;
        handle_riprel_post_xol(auprobe, regs, NULL);
        instruction_pointer_set(regs, utask->vaddr);
+
+       /* clear TF if it was set by us in arch_uprobe_pre_xol() */
+       if (!utask->autask.saved_tf)
+               regs->flags &= ~X86_EFLAGS_TF;
 }
 
 /*
@@ -676,38 +695,3 @@ bool arch_uprobe_skip_sstep(struct arch_uprobe *auprobe, struct pt_regs *regs)
                send_sig(SIGTRAP, current, 0);
        return ret;
 }
-
-void arch_uprobe_enable_step(struct arch_uprobe *auprobe)
-{
-       struct task_struct *task = current;
-       struct arch_uprobe_task *autask = &task->utask->autask;
-       struct pt_regs *regs = task_pt_regs(task);
-
-       autask->saved_tf = !!(regs->flags & X86_EFLAGS_TF);
-
-       regs->flags |= X86_EFLAGS_TF;
-       if (test_tsk_thread_flag(task, TIF_BLOCKSTEP))
-               set_task_blockstep(task, false);
-}
-
-void arch_uprobe_disable_step(struct arch_uprobe *auprobe)
-{
-       struct task_struct *task = current;
-       struct arch_uprobe_task *autask = &task->utask->autask;
-       bool trapped = (task->utask->state == UTASK_SSTEP_TRAPPED);
-       struct pt_regs *regs = task_pt_regs(task);
-       /*
-        * The state of TIF_BLOCKSTEP was not saved so we can get an extra
-        * SIGTRAP if we do not clear TF. We need to examine the opcode to
-        * make it right.
-        */
-       if (unlikely(trapped)) {
-               if (!autask->saved_tf)
-                       regs->flags &= ~X86_EFLAGS_TF;
-       } else {
-               if (autask->saved_tf)
-                       send_sig(SIGTRAP, task, 0);
-               else if (!(auprobe->fixups & UPROBE_FIX_SETF))
-                       regs->flags &= ~X86_EFLAGS_TF;
-       }
-}
index 6d13027..095f0a2 100644 (file)
@@ -25,4 +25,5 @@ generic-y += siginfo.h
 generic-y += statfs.h
 generic-y += termios.h
 generic-y += topology.h
+generic-y += trace_clock.h
 generic-y += xor.h
diff --git a/include/asm-generic/trace_clock.h b/include/asm-generic/trace_clock.h
new file mode 100644 (file)
index 0000000..6726f1b
--- /dev/null
@@ -0,0 +1,16 @@
+#ifndef _ASM_GENERIC_TRACE_CLOCK_H
+#define _ASM_GENERIC_TRACE_CLOCK_H
+/*
+ * Arch-specific trace clocks.
+ */
+
+/*
+ * Additional trace clocks added to the trace_clocks
+ * array in kernel/trace/trace.c
+ * None if the architecture has not defined it.
+ */
+#ifndef ARCH_TRACE_CLOCKS
+# define ARCH_TRACE_CLOCKS
+#endif
+
+#endif  /* _ASM_GENERIC_TRACE_CLOCK_H */
index 642928c..a3d4895 100644 (file)
@@ -86,6 +86,12 @@ struct trace_iterator {
        cpumask_var_t           started;
 };
 
+enum trace_iter_flags {
+       TRACE_FILE_LAT_FMT      = 1,
+       TRACE_FILE_ANNOTATE     = 2,
+       TRACE_FILE_TIME_IN_NS   = 4,
+};
+
 
 struct trace_event;
 
@@ -127,13 +133,13 @@ trace_current_buffer_lock_reserve(struct ring_buffer **current_buffer,
 void trace_current_buffer_unlock_commit(struct ring_buffer *buffer,
                                        struct ring_buffer_event *event,
                                        unsigned long flags, int pc);
-void trace_nowake_buffer_unlock_commit(struct ring_buffer *buffer,
-                                      struct ring_buffer_event *event,
-                                       unsigned long flags, int pc);
-void trace_nowake_buffer_unlock_commit_regs(struct ring_buffer *buffer,
-                                           struct ring_buffer_event *event,
-                                           unsigned long flags, int pc,
-                                           struct pt_regs *regs);
+void trace_buffer_unlock_commit(struct ring_buffer *buffer,
+                               struct ring_buffer_event *event,
+                               unsigned long flags, int pc);
+void trace_buffer_unlock_commit_regs(struct ring_buffer *buffer,
+                                    struct ring_buffer_event *event,
+                                    unsigned long flags, int pc,
+                                    struct pt_regs *regs);
 void trace_current_buffer_discard_commit(struct ring_buffer *buffer,
                                         struct ring_buffer_event *event);
 
index dd9900c..d97ed58 100644 (file)
@@ -527,9 +527,6 @@ __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);
 
 extern void ftrace_dump(enum ftrace_dump_mode oops_dump_mode);
 #else
-static inline __printf(1, 2)
-int trace_printk(const char *fmt, ...);
-
 static inline void tracing_start(void) { }
 static inline void tracing_stop(void) { }
 static inline void ftrace_off_permanent(void) { }
@@ -539,8 +536,8 @@ static inline void tracing_on(void) { }
 static inline void tracing_off(void) { }
 static inline int tracing_is_on(void) { return 0; }
 
-static inline int
-trace_printk(const char *fmt, ...)
+static inline __printf(1, 2)
+int trace_printk(const char *fmt, ...)
 {
        return 0;
 }
index 6c8835f..519777e 100644 (file)
@@ -159,13 +159,14 @@ int ring_buffer_record_is_on(struct ring_buffer *buffer);
 void ring_buffer_record_disable_cpu(struct ring_buffer *buffer, int cpu);
 void ring_buffer_record_enable_cpu(struct ring_buffer *buffer, int cpu);
 
-unsigned long ring_buffer_oldest_event_ts(struct ring_buffer *buffer, int cpu);
+u64 ring_buffer_oldest_event_ts(struct ring_buffer *buffer, int cpu);
 unsigned long ring_buffer_bytes_cpu(struct ring_buffer *buffer, int cpu);
 unsigned long ring_buffer_entries(struct ring_buffer *buffer);
 unsigned long ring_buffer_overruns(struct ring_buffer *buffer);
 unsigned long ring_buffer_entries_cpu(struct ring_buffer *buffer, int cpu);
 unsigned long ring_buffer_overrun_cpu(struct ring_buffer *buffer, int cpu);
 unsigned long ring_buffer_commit_overrun_cpu(struct ring_buffer *buffer, int cpu);
+unsigned long ring_buffer_dropped_events_cpu(struct ring_buffer *buffer, int cpu);
 
 u64 ring_buffer_time_stamp(struct ring_buffer *buffer, int cpu);
 void ring_buffer_normalize_time_stamp(struct ring_buffer *buffer,
index 4eb4902..d563f37 100644 (file)
@@ -12,6 +12,8 @@
 #include <linux/compiler.h>
 #include <linux/types.h>
 
+#include <asm/trace_clock.h>
+
 extern u64 notrace trace_clock_local(void);
 extern u64 notrace trace_clock(void);
 extern u64 notrace trace_clock_global(void);
index 2459457..4f628a6 100644 (file)
@@ -97,12 +97,12 @@ extern int uprobe_register(struct inode *inode, loff_t offset, struct uprobe_con
 extern void uprobe_unregister(struct inode *inode, loff_t offset, struct uprobe_consumer *uc);
 extern int uprobe_mmap(struct vm_area_struct *vma);
 extern void uprobe_munmap(struct vm_area_struct *vma, unsigned long start, unsigned long end);
+extern void uprobe_start_dup_mmap(void);
+extern void uprobe_end_dup_mmap(void);
 extern void uprobe_dup_mmap(struct mm_struct *oldmm, struct mm_struct *newmm);
 extern void uprobe_free_utask(struct task_struct *t);
 extern void uprobe_copy_process(struct task_struct *t);
 extern unsigned long __weak uprobe_get_swbp_addr(struct pt_regs *regs);
-extern void __weak arch_uprobe_enable_step(struct arch_uprobe *arch);
-extern void __weak arch_uprobe_disable_step(struct arch_uprobe *arch);
 extern int uprobe_post_sstep_notifier(struct pt_regs *regs);
 extern int uprobe_pre_sstep_notifier(struct pt_regs *regs);
 extern void uprobe_notify_resume(struct pt_regs *regs);
@@ -129,6 +129,12 @@ static inline void
 uprobe_munmap(struct vm_area_struct *vma, unsigned long start, unsigned long end)
 {
 }
+static inline void uprobe_start_dup_mmap(void)
+{
+}
+static inline void uprobe_end_dup_mmap(void)
+{
+}
 static inline void
 uprobe_dup_mmap(struct mm_struct *oldmm, struct mm_struct *newmm)
 {
index a763888..40dc5e8 100644 (file)
@@ -545,8 +545,7 @@ ftrace_raw_event_##call(void *__data, proto)                                \
        { assign; }                                                     \
                                                                        \
        if (!filter_current_check_discard(buffer, event_call, entry, event)) \
-               trace_nowake_buffer_unlock_commit(buffer,               \
-                                                 event, irq_flags, pc); \
+               trace_buffer_unlock_commit(buffer, event, irq_flags, pc); \
 }
 /*
  * The ftrace_test_probe is compiled out, it is only here as a build time check
@@ -620,79 +619,6 @@ __attribute__((section("_ftrace_events"))) *__event_##call = &event_##call
 
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 
-/*
- * Define the insertion callback to perf events
- *
- * The job is very similar to ftrace_raw_event_<call> except that we don't
- * insert in the ring buffer but in a perf counter.
- *
- * static void ftrace_perf_<call>(proto)
- * {
- *     struct ftrace_data_offsets_<call> __maybe_unused __data_offsets;
- *     struct ftrace_event_call *event_call = &event_<call>;
- *     extern void perf_tp_event(int, u64, u64, void *, int);
- *     struct ftrace_raw_##call *entry;
- *     struct perf_trace_buf *trace_buf;
- *     u64 __addr = 0, __count = 1;
- *     unsigned long irq_flags;
- *     struct trace_entry *ent;
- *     int __entry_size;
- *     int __data_size;
- *     int __cpu
- *     int pc;
- *
- *     pc = preempt_count();
- *
- *     __data_size = ftrace_get_offsets_<call>(&__data_offsets, args);
- *
- *     // Below we want to get the aligned size by taking into account
- *     // the u32 field that will later store the buffer size
- *     __entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),
- *                          sizeof(u64));
- *     __entry_size -= sizeof(u32);
- *
- *     // Protect the non nmi buffer
- *     // This also protects the rcu read side
- *     local_irq_save(irq_flags);
- *     __cpu = smp_processor_id();
- *
- *     if (in_nmi())
- *             trace_buf = rcu_dereference_sched(perf_trace_buf_nmi);
- *     else
- *             trace_buf = rcu_dereference_sched(perf_trace_buf);
- *
- *     if (!trace_buf)
- *             goto end;
- *
- *     trace_buf = per_cpu_ptr(trace_buf, __cpu);
- *
- *     // Avoid recursion from perf that could mess up the buffer
- *     if (trace_buf->recursion++)
- *             goto end_recursion;
- *
- *     raw_data = trace_buf->buf;
- *
- *     // Make recursion update visible before entering perf_tp_event
- *     // so that we protect from perf recursions.
- *
- *     barrier();
- *
- *     //zero dead bytes from alignment to avoid stack leak to userspace:
- *     *(u64 *)(&raw_data[__entry_size - sizeof(u64)]) = 0ULL;
- *     entry = (struct ftrace_raw_<call> *)raw_data;
- *     ent = &entry->ent;
- *     tracing_generic_entry_update(ent, irq_flags, pc);
- *     ent->type = event_call->id;
- *
- *     <tstruct> <- do some jobs with dynamic arrays
- *
- *     <assign>  <- affect our values
- *
- *     perf_tp_event(event_call->id, __addr, __count, entry,
- *                  __entry_size);  <- submit them to perf counter
- *
- * }
- */
 
 #ifdef CONFIG_PERF_EVENTS
 
index 31966a4..84bc419 100644 (file)
@@ -31,27 +31,4 @@ struct syscall_metadata {
        struct ftrace_event_call *exit_event;
 };
 
-#ifdef CONFIG_FTRACE_SYSCALLS
-extern unsigned long arch_syscall_addr(int nr);
-extern int init_syscall_trace(struct ftrace_event_call *call);
-
-extern int reg_event_syscall_enter(struct ftrace_event_call *call);
-extern void unreg_event_syscall_enter(struct ftrace_event_call *call);
-extern int reg_event_syscall_exit(struct ftrace_event_call *call);
-extern void unreg_event_syscall_exit(struct ftrace_event_call *call);
-extern int
-ftrace_format_syscall(struct ftrace_event_call *call, struct trace_seq *s);
-enum print_line_t print_syscall_enter(struct trace_iterator *iter, int flags,
-                                     struct trace_event *event);
-enum print_line_t print_syscall_exit(struct trace_iterator *iter, int flags,
-                                    struct trace_event *event);
-#endif
-
-#ifdef CONFIG_PERF_EVENTS
-int perf_sysenter_enable(struct ftrace_event_call *call);
-void perf_sysenter_disable(struct ftrace_event_call *call);
-int perf_sysexit_enable(struct ftrace_event_call *call);
-void perf_sysexit_disable(struct ftrace_event_call *call);
-#endif
-
 #endif /* _TRACE_SYSCALL_H */
index 5cc4e7e..dea7acf 100644 (file)
@@ -33,6 +33,7 @@
 #include <linux/ptrace.h>      /* user_enable_single_step */
 #include <linux/kdebug.h>      /* notifier mechanism */
 #include "../../mm/internal.h" /* munlock_vma_page */
+#include <linux/percpu-rwsem.h>
 
 #include <linux/uprobes.h>
 
@@ -71,6 +72,8 @@ static struct mutex uprobes_mutex[UPROBES_HASH_SZ];
 static struct mutex uprobes_mmap_mutex[UPROBES_HASH_SZ];
 #define uprobes_mmap_hash(v)   (&uprobes_mmap_mutex[((unsigned long)(v)) % UPROBES_HASH_SZ])
 
+static struct percpu_rw_semaphore dup_mmap_sem;
+
 /*
  * uprobe_events allows us to skip the uprobe_mmap if there are no uprobe
  * events active at this time.  Probably a fine grained per inode count is
@@ -766,10 +769,13 @@ static int register_for_each_vma(struct uprobe *uprobe, bool is_register)
        struct map_info *info;
        int err = 0;
 
+       percpu_down_write(&dup_mmap_sem);
        info = build_map_info(uprobe->inode->i_mapping,
                                        uprobe->offset, is_register);
-       if (IS_ERR(info))
-               return PTR_ERR(info);
+       if (IS_ERR(info)) {
+               err = PTR_ERR(info);
+               goto out;
+       }
 
        while (info) {
                struct mm_struct *mm = info->mm;
@@ -799,7 +805,8 @@ static int register_for_each_vma(struct uprobe *uprobe, bool is_register)
                mmput(mm);
                info = free_map_info(info);
        }
-
+ out:
+       percpu_up_write(&dup_mmap_sem);
        return err;
 }
 
@@ -1131,6 +1138,16 @@ void uprobe_clear_state(struct mm_struct *mm)
        kfree(area);
 }
 
+void uprobe_start_dup_mmap(void)
+{
+       percpu_down_read(&dup_mmap_sem);
+}
+
+void uprobe_end_dup_mmap(void)
+{
+       percpu_up_read(&dup_mmap_sem);
+}
+
 void uprobe_dup_mmap(struct mm_struct *oldmm, struct mm_struct *newmm)
 {
        newmm->uprobes_state.xol_area = NULL;
@@ -1199,6 +1216,11 @@ static unsigned long xol_get_insn_slot(struct uprobe *uprobe, unsigned long slot
        vaddr = kmap_atomic(area->page);
        memcpy(vaddr + offset, uprobe->arch.insn, MAX_UINSN_BYTES);
        kunmap_atomic(vaddr);
+       /*
+        * We probably need flush_icache_user_range() but it needs vma.
+        * This should work on supported architectures too.
+        */
+       flush_dcache_page(area->page);
 
        return current->utask->xol_vaddr;
 }
@@ -1430,16 +1452,6 @@ static struct uprobe *find_active_uprobe(unsigned long bp_vaddr, int *is_swbp)
        return uprobe;
 }
 
-void __weak arch_uprobe_enable_step(struct arch_uprobe *arch)
-{
-       user_enable_single_step(current);
-}
-
-void __weak arch_uprobe_disable_step(struct arch_uprobe *arch)
-{
-       user_disable_single_step(current);
-}
-
 /*
  * Run handler and ask thread to singlestep.
  * Ensure all non-fatal signals cannot interrupt thread while it singlesteps.
@@ -1493,7 +1505,6 @@ static void handle_swbp(struct pt_regs *regs)
                goto out;
 
        if (!pre_ssout(uprobe, regs, bp_vaddr)) {
-               arch_uprobe_enable_step(&uprobe->arch);
                utask->active_uprobe = uprobe;
                utask->state = UTASK_SSTEP;
                return;
@@ -1525,7 +1536,6 @@ static void handle_singlestep(struct uprobe_task *utask, struct pt_regs *regs)
        else
                WARN_ON_ONCE(1);
 
-       arch_uprobe_disable_step(&uprobe->arch);
        put_uprobe(uprobe);
        utask->active_uprobe = NULL;
        utask->state = UTASK_RUNNING;
@@ -1604,6 +1614,9 @@ static int __init init_uprobes(void)
                mutex_init(&uprobes_mmap_mutex[i]);
        }
 
+       if (percpu_init_rwsem(&dup_mmap_sem))
+               return -ENOMEM;
+
        return register_die_notifier(&uprobe_exception_nb);
 }
 module_init(init_uprobes);
index 8b20ab7..c497e57 100644 (file)
@@ -352,6 +352,7 @@ static int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)
        unsigned long charge;
        struct mempolicy *pol;
 
+       uprobe_start_dup_mmap();
        down_write(&oldmm->mmap_sem);
        flush_cache_dup_mm(oldmm);
        uprobe_dup_mmap(oldmm, mm);
@@ -469,6 +470,7 @@ out:
        up_write(&mm->mmap_sem);
        flush_tlb_mm(oldmm);
        up_write(&oldmm->mmap_sem);
+       uprobe_end_dup_mmap();
        return retval;
 fail_nomem_anon_vma_fork:
        mpol_put(pol);
index 4cea4f4..5d89335 100644 (file)
@@ -119,6 +119,7 @@ config TRACING
        select BINARY_PRINTF
        select EVENT_TRACING
        select TRACE_CLOCK
+       select IRQ_WORK
 
 config GENERIC_TRACER
        bool
index 9dcf15d..4451aa3 100644 (file)
@@ -2868,7 +2868,7 @@ static int __init ftrace_mod_cmd_init(void)
 {
        return register_ftrace_command(&ftrace_mod_cmd);
 }
-device_initcall(ftrace_mod_cmd_init);
+core_initcall(ftrace_mod_cmd_init);
 
 static void function_trace_probe_call(unsigned long ip, unsigned long parent_ip,
                                      struct ftrace_ops *op, struct pt_regs *pt_regs)
@@ -4055,7 +4055,7 @@ static int __init ftrace_nodyn_init(void)
        ftrace_enabled = 1;
        return 0;
 }
-device_initcall(ftrace_nodyn_init);
+core_initcall(ftrace_nodyn_init);
 
 static inline int ftrace_init_dyn_debugfs(struct dentry *d_tracer) { return 0; }
 static inline void ftrace_startup_enable(int command) { }
@@ -4381,7 +4381,7 @@ ftrace_pid_write(struct file *filp, const char __user *ubuf,
        if (strlen(tmp) == 0)
                return 1;
 
-       ret = strict_strtol(tmp, 10, &val);
+       ret = kstrtol(tmp, 10, &val);
        if (ret < 0)
                return ret;
 
index b979426..3c7834c 100644 (file)
@@ -460,9 +460,10 @@ struct ring_buffer_per_cpu {
        unsigned long                   lost_events;
        unsigned long                   last_overrun;
        local_t                         entries_bytes;
-       local_t                         commit_overrun;
-       local_t                         overrun;
        local_t                         entries;
+       local_t                         overrun;
+       local_t                         commit_overrun;
+       local_t                         dropped_events;
        local_t                         committing;
        local_t                         commits;
        unsigned long                   read;
@@ -1820,7 +1821,7 @@ rb_add_time_stamp(struct ring_buffer_event *event, u64 delta)
 }
 
 /**
- * ring_buffer_update_event - update event type and data
+ * rb_update_event - update event type and data
  * @event: the even to update
  * @type: the type of event
  * @length: the size of the event field in the ring buffer
@@ -2155,8 +2156,10 @@ rb_move_tail(struct ring_buffer_per_cpu *cpu_buffer,
                         * If we are not in overwrite mode,
                         * this is easy, just stop here.
                         */
-                       if (!(buffer->flags & RB_FL_OVERWRITE))
+                       if (!(buffer->flags & RB_FL_OVERWRITE)) {
+                               local_inc(&cpu_buffer->dropped_events);
                                goto out_reset;
+                       }
 
                        ret = rb_handle_head_page(cpu_buffer,
                                                  tail_page,
@@ -2720,8 +2723,8 @@ EXPORT_SYMBOL_GPL(ring_buffer_discard_commit);
  * and not the length of the event which would hold the header.
  */
 int ring_buffer_write(struct ring_buffer *buffer,
-                       unsigned long length,
-                       void *data)
+                     unsigned long length,
+                     void *data)
 {
        struct ring_buffer_per_cpu *cpu_buffer;
        struct ring_buffer_event *event;
@@ -2929,12 +2932,12 @@ rb_num_of_entries(struct ring_buffer_per_cpu *cpu_buffer)
  * @buffer: The ring buffer
  * @cpu: The per CPU buffer to read from.
  */
-unsigned long ring_buffer_oldest_event_ts(struct ring_buffer *buffer, int cpu)
+u64 ring_buffer_oldest_event_ts(struct ring_buffer *buffer, int cpu)
 {
        unsigned long flags;
        struct ring_buffer_per_cpu *cpu_buffer;
        struct buffer_page *bpage;
-       unsigned long ret;
+       u64 ret;
 
        if (!cpumask_test_cpu(cpu, buffer->cpumask))
                return 0;
@@ -2995,7 +2998,8 @@ unsigned long ring_buffer_entries_cpu(struct ring_buffer *buffer, int cpu)
 EXPORT_SYMBOL_GPL(ring_buffer_entries_cpu);
 
 /**
- * ring_buffer_overrun_cpu - get the number of overruns in a cpu_buffer
+ * ring_buffer_overrun_cpu - get the number of overruns caused by the ring
+ * buffer wrapping around (only if RB_FL_OVERWRITE is on).
  * @buffer: The ring buffer
  * @cpu: The per CPU buffer to get the number of overruns from
  */
@@ -3015,7 +3019,9 @@ unsigned long ring_buffer_overrun_cpu(struct ring_buffer *buffer, int cpu)
 EXPORT_SYMBOL_GPL(ring_buffer_overrun_cpu);
 
 /**
- * ring_buffer_commit_overrun_cpu - get the number of overruns caused by commits
+ * ring_buffer_commit_overrun_cpu - get the number of overruns caused by
+ * commits failing due to the buffer wrapping around while there are uncommitted
+ * events, such as during an interrupt storm.
  * @buffer: The ring buffer
  * @cpu: The per CPU buffer to get the number of overruns from
  */
@@ -3036,6 +3042,28 @@ ring_buffer_commit_overrun_cpu(struct ring_buffer *buffer, int cpu)
 EXPORT_SYMBOL_GPL(ring_buffer_commit_overrun_cpu);
 
 /**
+ * ring_buffer_dropped_events_cpu - get the number of dropped events caused by
+ * the ring buffer filling up (only if RB_FL_OVERWRITE is off).
+ * @buffer: The ring buffer
+ * @cpu: The per CPU buffer to get the number of overruns from
+ */
+unsigned long
+ring_buffer_dropped_events_cpu(struct ring_buffer *buffer, int cpu)
+{
+       struct ring_buffer_per_cpu *cpu_buffer;
+       unsigned long ret;
+
+       if (!cpumask_test_cpu(cpu, buffer->cpumask))
+               return 0;
+
+       cpu_buffer = buffer->buffers[cpu];
+       ret = local_read(&cpu_buffer->dropped_events);
+
+       return ret;
+}
+EXPORT_SYMBOL_GPL(ring_buffer_dropped_events_cpu);
+
+/**
  * ring_buffer_entries - get the number of entries in a buffer
  * @buffer: The ring buffer
  *
@@ -3864,9 +3892,10 @@ rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer)
        local_set(&cpu_buffer->reader_page->page->commit, 0);
        cpu_buffer->reader_page->read = 0;
 
-       local_set(&cpu_buffer->commit_overrun, 0);
        local_set(&cpu_buffer->entries_bytes, 0);
        local_set(&cpu_buffer->overrun, 0);
+       local_set(&cpu_buffer->commit_overrun, 0);
+       local_set(&cpu_buffer->dropped_events, 0);
        local_set(&cpu_buffer->entries, 0);
        local_set(&cpu_buffer->committing, 0);
        local_set(&cpu_buffer->commits, 0);
index 31e4f55..b69cc38 100644 (file)
@@ -19,6 +19,7 @@
 #include <linux/seq_file.h>
 #include <linux/notifier.h>
 #include <linux/irqflags.h>
+#include <linux/irq_work.h>
 #include <linux/debugfs.h>
 #include <linux/pagemap.h>
 #include <linux/hardirq.h>
@@ -78,6 +79,21 @@ static int dummy_set_flag(u32 old_flags, u32 bit, int set)
 }
 
 /*
+ * To prevent the comm cache from being overwritten when no
+ * tracing is active, only save the comm when a trace event
+ * occurred.
+ */
+static DEFINE_PER_CPU(bool, trace_cmdline_save);
+
+/*
+ * When a reader is waiting for data, then this variable is
+ * set to true.
+ */
+static bool trace_wakeup_needed;
+
+static struct irq_work trace_work_wakeup;
+
+/*
  * Kill all tracing for good (never come back).
  * It is initialized to 1 but will turn to zero if the initialization
  * of the tracer is successful. But that is the only place that sets
@@ -139,6 +155,18 @@ static int __init set_ftrace_dump_on_oops(char *str)
 }
 __setup("ftrace_dump_on_oops", set_ftrace_dump_on_oops);
 
+
+static char trace_boot_options_buf[MAX_TRACER_SIZE] __initdata;
+static char *trace_boot_options __initdata;
+
+static int __init set_trace_boot_options(char *str)
+{
+       strncpy(trace_boot_options_buf, str, MAX_TRACER_SIZE);
+       trace_boot_options = trace_boot_options_buf;
+       return 0;
+}
+__setup("trace_options=", set_trace_boot_options);
+
 unsigned long long ns2usecs(cycle_t nsec)
 {
        nsec += 500;
@@ -198,20 +226,9 @@ static struct trace_array  max_tr;
 
 static DEFINE_PER_CPU(struct trace_array_cpu, max_tr_data);
 
-/* tracer_enabled is used to toggle activation of a tracer */
-static int                     tracer_enabled = 1;
-
-/**
- * tracing_is_enabled - return tracer_enabled status
- *
- * This function is used by other tracers to know the status
- * of the tracer_enabled flag.  Tracers may use this function
- * to know if it should enable their features when starting
- * up. See irqsoff tracer for an example (start_irqsoff_tracer).
- */
 int tracing_is_enabled(void)
 {
-       return tracer_enabled;
+       return tracing_is_on();
 }
 
 /*
@@ -333,12 +350,18 @@ unsigned long trace_flags = TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK |
 static int trace_stop_count;
 static DEFINE_RAW_SPINLOCK(tracing_start_lock);
 
-static void wakeup_work_handler(struct work_struct *work)
+/**
+ * trace_wake_up - wake up tasks waiting for trace input
+ *
+ * Schedules a delayed work to wake up any task that is blocked on the
+ * trace_wait queue. These is used with trace_poll for tasks polling the
+ * trace.
+ */
+static void trace_wake_up(struct irq_work *work)
 {
-       wake_up(&trace_wait);
-}
+       wake_up_all(&trace_wait);
 
-static DECLARE_DELAYED_WORK(wakeup_work, wakeup_work_handler);
+}
 
 /**
  * tracing_on - enable tracing buffers
@@ -393,22 +416,6 @@ int tracing_is_on(void)
 }
 EXPORT_SYMBOL_GPL(tracing_is_on);
 
-/**
- * trace_wake_up - wake up tasks waiting for trace input
- *
- * Schedules a delayed work to wake up any task that is blocked on the
- * trace_wait queue. These is used with trace_poll for tasks polling the
- * trace.
- */
-void trace_wake_up(void)
-{
-       const unsigned long delay = msecs_to_jiffies(2);
-
-       if (trace_flags & TRACE_ITER_BLOCK)
-               return;
-       schedule_delayed_work(&wakeup_work, delay);
-}
-
 static int __init set_buf_size(char *str)
 {
        unsigned long buf_size;
@@ -431,7 +438,7 @@ static int __init set_tracing_thresh(char *str)
 
        if (!str)
                return 0;
-       ret = strict_strtoul(str, 0, &threshold);
+       ret = kstrtoul(str, 0, &threshold);
        if (ret < 0)
                return 0;
        tracing_thresh = threshold * 1000;
@@ -477,10 +484,12 @@ static const char *trace_options[] = {
 static struct {
        u64 (*func)(void);
        const char *name;
+       int in_ns;              /* is this clock in nanoseconds? */
 } trace_clocks[] = {
-       { trace_clock_local,    "local" },
-       { trace_clock_global,   "global" },
-       { trace_clock_counter,  "counter" },
+       { trace_clock_local,    "local",        1 },
+       { trace_clock_global,   "global",       1 },
+       { trace_clock_counter,  "counter",      0 },
+       ARCH_TRACE_CLOCKS
 };
 
 int trace_clock_id;
@@ -757,6 +766,40 @@ update_max_tr_single(struct trace_array *tr, struct task_struct *tsk, int cpu)
 }
 #endif /* CONFIG_TRACER_MAX_TRACE */
 
+static void default_wait_pipe(struct trace_iterator *iter)
+{
+       DEFINE_WAIT(wait);
+
+       prepare_to_wait(&trace_wait, &wait, TASK_INTERRUPTIBLE);
+
+       /*
+        * The events can happen in critical sections where
+        * checking a work queue can cause deadlocks.
+        * After adding a task to the queue, this flag is set
+        * only to notify events to try to wake up the queue
+        * using irq_work.
+        *
+        * We don't clear it even if the buffer is no longer
+        * empty. The flag only causes the next event to run
+        * irq_work to do the work queue wake up. The worse
+        * that can happen if we race with !trace_empty() is that
+        * an event will cause an irq_work to try to wake up
+        * an empty queue.
+        *
+        * There's no reason to protect this flag either, as
+        * the work queue and irq_work logic will do the necessary
+        * synchronization for the wake ups. The only thing
+        * that is necessary is that the wake up happens after
+        * a task has been queued. It's OK for spurious wake ups.
+        */
+       trace_wakeup_needed = true;
+
+       if (trace_empty(iter))
+               schedule();
+
+       finish_wait(&trace_wait, &wait);
+}
+
 /**
  * register_tracer - register a tracer with the ftrace system.
  * @type - the plugin for the tracer
@@ -875,32 +918,6 @@ int register_tracer(struct tracer *type)
        return ret;
 }
 
-void unregister_tracer(struct tracer *type)
-{
-       struct tracer **t;
-
-       mutex_lock(&trace_types_lock);
-       for (t = &trace_types; *t; t = &(*t)->next) {
-               if (*t == type)
-                       goto found;
-       }
-       pr_info("Tracer %s not registered\n", type->name);
-       goto out;
-
- found:
-       *t = (*t)->next;
-
-       if (type == current_trace && tracer_enabled) {
-               tracer_enabled = 0;
-               tracing_stop();
-               if (current_trace->stop)
-                       current_trace->stop(&global_trace);
-               current_trace = &nop_trace;
-       }
-out:
-       mutex_unlock(&trace_types_lock);
-}
-
 void tracing_reset(struct trace_array *tr, int cpu)
 {
        struct ring_buffer *buffer = tr->buffer;
@@ -1131,10 +1148,14 @@ void trace_find_cmdline(int pid, char comm[])
 
 void tracing_record_cmdline(struct task_struct *tsk)
 {
-       if (atomic_read(&trace_record_cmdline_disabled) || !tracer_enabled ||
-           !tracing_is_on())
+       if (atomic_read(&trace_record_cmdline_disabled) || !tracing_is_on())
                return;
 
+       if (!__this_cpu_read(trace_cmdline_save))
+               return;
+
+       __this_cpu_write(trace_cmdline_save, false);
+
        trace_save_cmdline(tsk);
 }
 
@@ -1178,27 +1199,36 @@ trace_buffer_lock_reserve(struct ring_buffer *buffer,
        return event;
 }
 
+void
+__buffer_unlock_commit(struct ring_buffer *buffer, struct ring_buffer_event *event)
+{
+       __this_cpu_write(trace_cmdline_save, true);
+       if (trace_wakeup_needed) {
+               trace_wakeup_needed = false;
+               /* irq_work_queue() supplies it's own memory barriers */
+               irq_work_queue(&trace_work_wakeup);
+       }
+       ring_buffer_unlock_commit(buffer, event);
+}
+
 static inline void
 __trace_buffer_unlock_commit(struct ring_buffer *buffer,
                             struct ring_buffer_event *event,
-                            unsigned long flags, int pc,
-                            int wake)
+                            unsigned long flags, int pc)
 {
-       ring_buffer_unlock_commit(buffer, event);
+       __buffer_unlock_commit(buffer, event);
 
        ftrace_trace_stack(buffer, flags, 6, pc);
        ftrace_trace_userstack(buffer, flags, pc);
-
-       if (wake)
-               trace_wake_up();
 }
 
 void trace_buffer_unlock_commit(struct ring_buffer *buffer,
                                struct ring_buffer_event *event,
                                unsigned long flags, int pc)
 {
-       __trace_buffer_unlock_commit(buffer, event, flags, pc, 1);
+       __trace_buffer_unlock_commit(buffer, event, flags, pc);
 }
+EXPORT_SYMBOL_GPL(trace_buffer_unlock_commit);
 
 struct ring_buffer_event *
 trace_current_buffer_lock_reserve(struct ring_buffer **current_rb,
@@ -1215,29 +1245,21 @@ void trace_current_buffer_unlock_commit(struct ring_buffer *buffer,
                                        struct ring_buffer_event *event,
                                        unsigned long flags, int pc)
 {
-       __trace_buffer_unlock_commit(buffer, event, flags, pc, 1);
+       __trace_buffer_unlock_commit(buffer, event, flags, pc);
 }
 EXPORT_SYMBOL_GPL(trace_current_buffer_unlock_commit);
 
-void trace_nowake_buffer_unlock_commit(struct ring_buffer *buffer,
-                                      struct ring_buffer_event *event,
-                                      unsigned long flags, int pc)
+void trace_buffer_unlock_commit_regs(struct ring_buffer *buffer,
+                                    struct ring_buffer_event *event,
+                                    unsigned long flags, int pc,
+                                    struct pt_regs *regs)
 {
-       __trace_buffer_unlock_commit(buffer, event, flags, pc, 0);
-}
-EXPORT_SYMBOL_GPL(trace_nowake_buffer_unlock_commit);
-
-void trace_nowake_buffer_unlock_commit_regs(struct ring_buffer *buffer,
-                                           struct ring_buffer_event *event,
-                                           unsigned long flags, int pc,
-                                           struct pt_regs *regs)
-{
-       ring_buffer_unlock_commit(buffer, event);
+       __buffer_unlock_commit(buffer, event);
 
        ftrace_trace_stack_regs(buffer, flags, 0, pc, regs);
        ftrace_trace_userstack(buffer, flags, pc);
 }
-EXPORT_SYMBOL_GPL(trace_nowake_buffer_unlock_commit_regs);
+EXPORT_SYMBOL_GPL(trace_buffer_unlock_commit_regs);
 
 void trace_current_buffer_discard_commit(struct ring_buffer *buffer,
                                         struct ring_buffer_event *event)
@@ -1269,7 +1291,7 @@ trace_function(struct trace_array *tr,
        entry->parent_ip                = parent_ip;
 
        if (!filter_check_discard(call, entry, buffer, event))
-               ring_buffer_unlock_commit(buffer, event);
+               __buffer_unlock_commit(buffer, event);
 }
 
 void
@@ -1362,7 +1384,7 @@ static void __ftrace_trace_stack(struct ring_buffer *buffer,
        entry->size = trace.nr_entries;
 
        if (!filter_check_discard(call, entry, buffer, event))
-               ring_buffer_unlock_commit(buffer, event);
+               __buffer_unlock_commit(buffer, event);
 
  out:
        /* Again, don't let gcc optimize things here */
@@ -1458,7 +1480,7 @@ ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags, int pc)
 
        save_stack_trace_user(&trace);
        if (!filter_check_discard(call, entry, buffer, event))
-               ring_buffer_unlock_commit(buffer, event);
+               __buffer_unlock_commit(buffer, event);
 
  out_drop_count:
        __this_cpu_dec(user_stack_count);
@@ -1559,10 +1581,10 @@ static int alloc_percpu_trace_buffer(void)
        return -ENOMEM;
 }
 
+static int buffers_allocated;
+
 void trace_printk_init_buffers(void)
 {
-       static int buffers_allocated;
-
        if (buffers_allocated)
                return;
 
@@ -1571,7 +1593,38 @@ void trace_printk_init_buffers(void)
 
        pr_info("ftrace: Allocated trace_printk buffers\n");
 
+       /* Expand the buffers to set size */
+       tracing_update_buffers();
+
        buffers_allocated = 1;
+
+       /*
+        * trace_printk_init_buffers() can be called by modules.
+        * If that happens, then we need to start cmdline recording
+        * directly here. If the global_trace.buffer is already
+        * allocated here, then this was called by module code.
+        */
+       if (global_trace.buffer)
+               tracing_start_cmdline_record();
+}
+
+void trace_printk_start_comm(void)
+{
+       /* Start tracing comms if trace printk is set */
+       if (!buffers_allocated)
+               return;
+       tracing_start_cmdline_record();
+}
+
+static void trace_printk_start_stop_comm(int enabled)
+{
+       if (!buffers_allocated)
+               return;
+
+       if (enabled)
+               tracing_start_cmdline_record();
+       else
+               tracing_stop_cmdline_record();
 }
 
 /**
@@ -1622,7 +1675,7 @@ int trace_vbprintk(unsigned long ip, const char *fmt, va_list args)
 
        memcpy(entry->buf, tbuffer, sizeof(u32) * len);
        if (!filter_check_discard(call, entry, buffer, event)) {
-               ring_buffer_unlock_commit(buffer, event);
+               __buffer_unlock_commit(buffer, event);
                ftrace_trace_stack(buffer, flags, 6, pc);
        }
 
@@ -1693,7 +1746,7 @@ int trace_array_vprintk(struct trace_array *tr,
        memcpy(&entry->buf, tbuffer, len);
        entry->buf[len] = '\0';
        if (!filter_check_discard(call, entry, buffer, event)) {
-               ring_buffer_unlock_commit(buffer, event);
+               __buffer_unlock_commit(buffer, event);
                ftrace_trace_stack(buffer, flags, 6, pc);
        }
  out:
@@ -2426,6 +2479,10 @@ __tracing_open(struct inode *inode, struct file *file)
        if (ring_buffer_overruns(iter->tr->buffer))
                iter->iter_flags |= TRACE_FILE_ANNOTATE;
 
+       /* Output in nanoseconds only if we are using a clock in nanoseconds. */
+       if (trace_clocks[trace_clock_id].in_ns)
+               iter->iter_flags |= TRACE_FILE_TIME_IN_NS;
+
        /* stop the trace while dumping */
        tracing_stop();
 
@@ -2794,26 +2851,19 @@ static void set_tracer_flags(unsigned int mask, int enabled)
 
        if (mask == TRACE_ITER_OVERWRITE)
                ring_buffer_change_overwrite(global_trace.buffer, enabled);
+
+       if (mask == TRACE_ITER_PRINTK)
+               trace_printk_start_stop_comm(enabled);
 }
 
-static ssize_t
-tracing_trace_options_write(struct file *filp, const char __user *ubuf,
-                       size_t cnt, loff_t *ppos)
+static int trace_set_options(char *option)
 {
-       char buf[64];
        char *cmp;
        int neg = 0;
-       int ret;
+       int ret = 0;
        int i;
 
-       if (cnt >= sizeof(buf))
-               return -EINVAL;
-
-       if (copy_from_user(&buf, ubuf, cnt))
-               return -EFAULT;
-
-       buf[cnt] = 0;
-       cmp = strstrip(buf);
+       cmp = strstrip(option);
 
        if (strncmp(cmp, "no", 2) == 0) {
                neg = 1;
@@ -2832,10 +2882,25 @@ tracing_trace_options_write(struct file *filp, const char __user *ubuf,
                mutex_lock(&trace_types_lock);
                ret = set_tracer_option(current_trace, cmp, neg);
                mutex_unlock(&trace_types_lock);
-               if (ret)
-                       return ret;
        }
 
+       return ret;
+}
+
+static ssize_t
+tracing_trace_options_write(struct file *filp, const char __user *ubuf,
+                       size_t cnt, loff_t *ppos)
+{
+       char buf[64];
+
+       if (cnt >= sizeof(buf))
+               return -EINVAL;
+
+       if (copy_from_user(&buf, ubuf, cnt))
+               return -EFAULT;
+
+       trace_set_options(buf);
+
        *ppos += cnt;
 
        return cnt;
@@ -2940,56 +3005,6 @@ static const struct file_operations tracing_saved_cmdlines_fops = {
 };
 
 static ssize_t
-tracing_ctrl_read(struct file *filp, char __user *ubuf,
-                 size_t cnt, loff_t *ppos)
-{
-       char buf[64];
-       int r;
-
-       r = sprintf(buf, "%u\n", tracer_enabled);
-       return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
-}
-
-static ssize_t
-tracing_ctrl_write(struct file *filp, const char __user *ubuf,
-                  size_t cnt, loff_t *ppos)
-{
-       struct trace_array *tr = filp->private_data;
-       unsigned long val;
-       int ret;
-
-       ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
-       if (ret)
-               return ret;
-
-       val = !!val;
-
-       mutex_lock(&trace_types_lock);
-       if (tracer_enabled ^ val) {
-
-               /* Only need to warn if this is used to change the state */
-               WARN_ONCE(1, "tracing_enabled is deprecated. Use tracing_on");
-
-               if (val) {
-                       tracer_enabled = 1;
-                       if (current_trace->start)
-                               current_trace->start(tr);
-                       tracing_start();
-               } else {
-                       tracer_enabled = 0;
-                       tracing_stop();
-                       if (current_trace->stop)
-                               current_trace->stop(tr);
-               }
-       }
-       mutex_unlock(&trace_types_lock);
-
-       *ppos += cnt;
-
-       return cnt;
-}
-
-static ssize_t
 tracing_set_trace_read(struct file *filp, char __user *ubuf,
                       size_t cnt, loff_t *ppos)
 {
@@ -3030,6 +3045,10 @@ static int __tracing_resize_ring_buffer(unsigned long size, int cpu)
         */
        ring_buffer_expanded = 1;
 
+       /* May be called before buffers are initialized */
+       if (!global_trace.buffer)
+               return 0;
+
        ret = ring_buffer_resize(global_trace.buffer, size, cpu);
        if (ret < 0)
                return ret;
@@ -3325,6 +3344,10 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp)
        if (trace_flags & TRACE_ITER_LATENCY_FMT)
                iter->iter_flags |= TRACE_FILE_LAT_FMT;
 
+       /* Output in nanoseconds only if we are using a clock in nanoseconds. */
+       if (trace_clocks[trace_clock_id].in_ns)
+               iter->iter_flags |= TRACE_FILE_TIME_IN_NS;
+
        iter->cpu_file = cpu_file;
        iter->tr = &global_trace;
        mutex_init(&iter->mutex);
@@ -3385,19 +3408,6 @@ tracing_poll_pipe(struct file *filp, poll_table *poll_table)
        }
 }
 
-
-void default_wait_pipe(struct trace_iterator *iter)
-{
-       DEFINE_WAIT(wait);
-
-       prepare_to_wait(&trace_wait, &wait, TASK_INTERRUPTIBLE);
-
-       if (trace_empty(iter))
-               schedule();
-
-       finish_wait(&trace_wait, &wait);
-}
-
 /*
  * This is a make-shift waitqueue.
  * A tracer might use this callback on some rare cases:
@@ -3438,7 +3448,7 @@ static int tracing_wait_pipe(struct file *filp)
                        return -EINTR;
 
                /*
-                * We block until we read something and tracing is disabled.
+                * We block until we read something and tracing is enabled.
                 * We still block if tracing is disabled, but we have never
                 * read anything. This allows a user to cat this file, and
                 * then enable tracing. But after we have read something,
@@ -3446,7 +3456,7 @@ static int tracing_wait_pipe(struct file *filp)
                 *
                 * iter->pos will be 0 if we haven't read anything.
                 */
-               if (!tracer_enabled && iter->pos)
+               if (tracing_is_enabled() && iter->pos)
                        break;
        }
 
@@ -3955,7 +3965,7 @@ tracing_mark_write(struct file *filp, const char __user *ubuf,
        } else
                entry->buf[cnt] = '\0';
 
-       ring_buffer_unlock_commit(buffer, event);
+       __buffer_unlock_commit(buffer, event);
 
        written = cnt;
 
@@ -4016,6 +4026,14 @@ static ssize_t tracing_clock_write(struct file *filp, const char __user *ubuf,
        if (max_tr.buffer)
                ring_buffer_set_clock(max_tr.buffer, trace_clocks[i].func);
 
+       /*
+        * New clock may not be consistent with the previous clock.
+        * Reset the buffer so that it doesn't have incomparable timestamps.
+        */
+       tracing_reset_online_cpus(&global_trace);
+       if (max_tr.buffer)
+               tracing_reset_online_cpus(&max_tr);
+
        mutex_unlock(&trace_types_lock);
 
        *fpos += cnt;
@@ -4037,13 +4055,6 @@ static const struct file_operations tracing_max_lat_fops = {
        .llseek         = generic_file_llseek,
 };
 
-static const struct file_operations tracing_ctrl_fops = {
-       .open           = tracing_open_generic,
-       .read           = tracing_ctrl_read,
-       .write          = tracing_ctrl_write,
-       .llseek         = generic_file_llseek,
-};
-
 static const struct file_operations set_tracer_fops = {
        .open           = tracing_open_generic,
        .read           = tracing_set_trace_read,
@@ -4377,13 +4388,27 @@ tracing_stats_read(struct file *filp, char __user *ubuf,
        cnt = ring_buffer_bytes_cpu(tr->buffer, cpu);
        trace_seq_printf(s, "bytes: %ld\n", cnt);
 
-       t = ns2usecs(ring_buffer_oldest_event_ts(tr->buffer, cpu));
-       usec_rem = do_div(t, USEC_PER_SEC);
-       trace_seq_printf(s, "oldest event ts: %5llu.%06lu\n", t, usec_rem);
+       if (trace_clocks[trace_clock_id].in_ns) {
+               /* local or global for trace_clock */
+               t = ns2usecs(ring_buffer_oldest_event_ts(tr->buffer, cpu));
+               usec_rem = do_div(t, USEC_PER_SEC);
+               trace_seq_printf(s, "oldest event ts: %5llu.%06lu\n",
+                                                               t, usec_rem);
+
+               t = ns2usecs(ring_buffer_time_stamp(tr->buffer, cpu));
+               usec_rem = do_div(t, USEC_PER_SEC);
+               trace_seq_printf(s, "now ts: %5llu.%06lu\n", t, usec_rem);
+       } else {
+               /* counter or tsc mode for trace_clock */
+               trace_seq_printf(s, "oldest event ts: %llu\n",
+                               ring_buffer_oldest_event_ts(tr->buffer, cpu));
+
+               trace_seq_printf(s, "now ts: %llu\n",
+                               ring_buffer_time_stamp(tr->buffer, cpu));
+       }
 
-       t = ns2usecs(ring_buffer_time_stamp(tr->buffer, cpu));
-       usec_rem = do_div(t, USEC_PER_SEC);
-       trace_seq_printf(s, "now ts: %5llu.%06lu\n", t, usec_rem);
+       cnt = ring_buffer_dropped_events_cpu(tr->buffer, cpu);
+       trace_seq_printf(s, "dropped events: %ld\n", cnt);
 
        count = simple_read_from_buffer(ubuf, count, ppos, s->buffer, s->len);
 
@@ -4815,9 +4840,6 @@ static __init int tracer_init_debugfs(void)
 
        d_tracer = tracing_init_dentry();
 
-       trace_create_file("tracing_enabled", 0644, d_tracer,
-                       &global_trace, &tracing_ctrl_fops);
-
        trace_create_file("trace_options", 0644, d_tracer,
                        NULL, &tracing_iter_fops);
 
@@ -5089,6 +5111,7 @@ __init static int tracer_alloc_buffers(void)
 
        /* Only allocate trace_printk buffers if a trace_printk exists */
        if (__stop___trace_bprintk_fmt != __start___trace_bprintk_fmt)
+               /* Must be called before global_trace.buffer is allocated */
                trace_printk_init_buffers();
 
        /* To save memory, keep the ring buffer size to its minimum */
@@ -5136,6 +5159,7 @@ __init static int tracer_alloc_buffers(void)
 #endif
 
        trace_init_cmdlines();
+       init_irq_work(&trace_work_wakeup, trace_wake_up);
 
        register_tracer(&nop_trace);
        current_trace = &nop_trace;
@@ -5147,6 +5171,13 @@ __init static int tracer_alloc_buffers(void)
 
        register_die_notifier(&trace_die_notifier);
 
+       while (trace_boot_options) {
+               char *option;
+
+               option = strsep(&trace_boot_options, ",");
+               trace_set_options(option);
+       }
+
        return 0;
 
 out_free_cpumask:
index c15f528..c75d798 100644 (file)
@@ -285,8 +285,8 @@ struct tracer {
        int                     (*set_flag)(u32 old_flags, u32 bit, int set);
        struct tracer           *next;
        struct tracer_flags     *flags;
-       int                     print_max;
-       int                     use_max_tr;
+       bool                    print_max;
+       bool                    use_max_tr;
 };
 
 
@@ -327,7 +327,6 @@ trace_buffer_iter(struct trace_iterator *iter, int cpu)
 
 int tracer_init(struct tracer *t, struct trace_array *tr);
 int tracing_is_enabled(void);
-void trace_wake_up(void);
 void tracing_reset(struct trace_array *tr, int cpu);
 void tracing_reset_online_cpus(struct trace_array *tr);
 void tracing_reset_current(int cpu);
@@ -349,9 +348,6 @@ trace_buffer_lock_reserve(struct ring_buffer *buffer,
                          unsigned long len,
                          unsigned long flags,
                          int pc);
-void trace_buffer_unlock_commit(struct ring_buffer *buffer,
-                               struct ring_buffer_event *event,
-                               unsigned long flags, int pc);
 
 struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
                                                struct trace_array_cpu *data);
@@ -359,6 +355,9 @@ struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
 struct trace_entry *trace_find_next_entry(struct trace_iterator *iter,
                                          int *ent_cpu, u64 *ent_ts);
 
+void __buffer_unlock_commit(struct ring_buffer *buffer,
+                           struct ring_buffer_event *event);
+
 int trace_empty(struct trace_iterator *iter);
 
 void *trace_find_next_entry_inc(struct trace_iterator *iter);
@@ -367,7 +366,6 @@ void trace_init_global_iter(struct trace_iterator *iter);
 
 void tracing_iter_reset(struct trace_iterator *iter, int cpu);
 
-void default_wait_pipe(struct trace_iterator *iter);
 void poll_wait_pipe(struct trace_iterator *iter);
 
 void ftrace(struct trace_array *tr,
@@ -407,12 +405,7 @@ void tracing_sched_switch_assign_trace(struct trace_array *tr);
 void tracing_stop_sched_switch_record(void);
 void tracing_start_sched_switch_record(void);
 int register_tracer(struct tracer *type);
-void unregister_tracer(struct tracer *type);
 int is_tracing_stopped(void);
-enum trace_file_type {
-       TRACE_FILE_LAT_FMT      = 1,
-       TRACE_FILE_ANNOTATE     = 2,
-};
 
 extern cpumask_var_t __read_mostly tracing_buffer_mask;
 
@@ -841,6 +834,7 @@ extern const char *__start___trace_bprintk_fmt[];
 extern const char *__stop___trace_bprintk_fmt[];
 
 void trace_printk_init_buffers(void);
+void trace_printk_start_comm(void);
 
 #undef FTRACE_ENTRY
 #define FTRACE_ENTRY(call, struct_name, id, tstruct, print, filter)    \
index 8d3538b..95e9684 100644 (file)
@@ -77,7 +77,7 @@ probe_likely_condition(struct ftrace_branch_data *f, int val, int expect)
        entry->correct = val == expect;
 
        if (!filter_check_discard(call, entry, buffer, event))
-               ring_buffer_unlock_commit(buffer, event);
+               __buffer_unlock_commit(buffer, event);
 
  out:
        atomic_dec(&tr->data[cpu]->disabled);
@@ -199,7 +199,7 @@ __init static int init_branch_tracer(void)
        }
        return register_tracer(&branch_trace);
 }
-device_initcall(init_branch_tracer);
+core_initcall(init_branch_tracer);
 
 #else
 static inline
index d608d09..880073d 100644 (file)
@@ -491,19 +491,6 @@ static void t_stop(struct seq_file *m, void *p)
        mutex_unlock(&event_mutex);
 }
 
-static int
-ftrace_event_seq_open(struct inode *inode, struct file *file)
-{
-       const struct seq_operations *seq_ops;
-
-       if ((file->f_mode & FMODE_WRITE) &&
-           (file->f_flags & O_TRUNC))
-               ftrace_clear_events();
-
-       seq_ops = inode->i_private;
-       return seq_open(file, seq_ops);
-}
-
 static ssize_t
 event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
                  loff_t *ppos)
@@ -980,6 +967,9 @@ show_header(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
        return r;
 }
 
+static int ftrace_event_avail_open(struct inode *inode, struct file *file);
+static int ftrace_event_set_open(struct inode *inode, struct file *file);
+
 static const struct seq_operations show_event_seq_ops = {
        .start = t_start,
        .next = t_next,
@@ -995,14 +985,14 @@ static const struct seq_operations show_set_event_seq_ops = {
 };
 
 static const struct file_operations ftrace_avail_fops = {
-       .open = ftrace_event_seq_open,
+       .open = ftrace_event_avail_open,
        .read = seq_read,
        .llseek = seq_lseek,
        .release = seq_release,
 };
 
 static const struct file_operations ftrace_set_event_fops = {
-       .open = ftrace_event_seq_open,
+       .open = ftrace_event_set_open,
        .read = seq_read,
        .write = ftrace_event_write,
        .llseek = seq_lseek,
@@ -1078,6 +1068,26 @@ static struct dentry *event_trace_events_dir(void)
        return d_events;
 }
 
+static int
+ftrace_event_avail_open(struct inode *inode, struct file *file)
+{
+       const struct seq_operations *seq_ops = &show_event_seq_ops;
+
+       return seq_open(file, seq_ops);
+}
+
+static int
+ftrace_event_set_open(struct inode *inode, struct file *file)
+{
+       const struct seq_operations *seq_ops = &show_set_event_seq_ops;
+
+       if ((file->f_mode & FMODE_WRITE) &&
+           (file->f_flags & O_TRUNC))
+               ftrace_clear_events();
+
+       return seq_open(file, seq_ops);
+}
+
 static struct dentry *
 event_subsystem_dir(const char *name, struct dentry *d_events)
 {
@@ -1489,6 +1499,9 @@ static __init int event_trace_enable(void)
                if (ret)
                        pr_warn("Failed to enable trace event: %s\n", token);
        }
+
+       trace_printk_start_comm();
+
        return 0;
 }
 
@@ -1505,15 +1518,13 @@ static __init int event_trace_init(void)
                return 0;
 
        entry = debugfs_create_file("available_events", 0444, d_tracer,
-                                   (void *)&show_event_seq_ops,
-                                   &ftrace_avail_fops);
+                                   NULL, &ftrace_avail_fops);
        if (!entry)
                pr_warning("Could not create debugfs "
                           "'available_events' entry\n");
 
        entry = debugfs_create_file("set_event", 0644, d_tracer,
-                                   (void *)&show_set_event_seq_ops,
-                                   &ftrace_set_event_fops);
+                                   NULL, &ftrace_set_event_fops);
        if (!entry)
                pr_warning("Could not create debugfs "
                           "'set_event' entry\n");
@@ -1749,7 +1760,7 @@ function_test_events_call(unsigned long ip, unsigned long parent_ip,
        entry->ip                       = ip;
        entry->parent_ip                = parent_ip;
 
-       trace_nowake_buffer_unlock_commit(buffer, event, flags, pc);
+       trace_buffer_unlock_commit(buffer, event, flags, pc);
 
  out:
        atomic_dec(&per_cpu(ftrace_test_event_disable, cpu));
index c154797..e5b0ca8 100644 (file)
@@ -1000,9 +1000,9 @@ static int init_pred(struct filter_parse_state *ps,
                }
        } else {
                if (field->is_signed)
-                       ret = strict_strtoll(pred->regex.pattern, 0, &val);
+                       ret = kstrtoll(pred->regex.pattern, 0, &val);
                else
-                       ret = strict_strtoull(pred->regex.pattern, 0, &val);
+                       ret = kstrtoull(pred->regex.pattern, 0, &val);
                if (ret) {
                        parse_error(ps, FILT_ERR_ILLEGAL_INTVAL, 0);
                        return -EINVAL;
index 507a7a9..bb227e3 100644 (file)
@@ -366,7 +366,7 @@ ftrace_trace_onoff_callback(struct ftrace_hash *hash,
         * We use the callback data field (which is a pointer)
         * as our counter.
         */
-       ret = strict_strtoul(number, 0, (unsigned long *)&count);
+       ret = kstrtoul(number, 0, (unsigned long *)&count);
        if (ret)
                return ret;
 
@@ -411,5 +411,4 @@ static __init int init_function_trace(void)
        init_func_cmd_traceon();
        return register_tracer(&function_trace);
 }
-device_initcall(init_function_trace);
-
+core_initcall(init_function_trace);
index 99b4378..4edb4b7 100644 (file)
@@ -223,7 +223,7 @@ int __trace_graph_entry(struct trace_array *tr,
        entry   = ring_buffer_event_data(event);
        entry->graph_ent                        = *trace;
        if (!filter_current_check_discard(buffer, call, entry, event))
-               ring_buffer_unlock_commit(buffer, event);
+               __buffer_unlock_commit(buffer, event);
 
        return 1;
 }
@@ -327,7 +327,7 @@ void __trace_graph_return(struct trace_array *tr,
        entry   = ring_buffer_event_data(event);
        entry->ret                              = *trace;
        if (!filter_current_check_discard(buffer, call, entry, event))
-               ring_buffer_unlock_commit(buffer, event);
+               __buffer_unlock_commit(buffer, event);
 }
 
 void trace_graph_return(struct ftrace_graph_ret *trace)
@@ -1474,4 +1474,4 @@ static __init int init_graph_trace(void)
        return register_tracer(&graph_trace);
 }
 
-device_initcall(init_graph_trace);
+core_initcall(init_graph_trace);
index d98ee82..5ffce7b 100644 (file)
@@ -604,7 +604,7 @@ static struct tracer irqsoff_tracer __read_mostly =
        .reset          = irqsoff_tracer_reset,
        .start          = irqsoff_tracer_start,
        .stop           = irqsoff_tracer_stop,
-       .print_max      = 1,
+       .print_max      = true,
        .print_header   = irqsoff_print_header,
        .print_line     = irqsoff_print_line,
        .flags          = &tracer_flags,
@@ -614,7 +614,7 @@ static struct tracer irqsoff_tracer __read_mostly =
 #endif
        .open           = irqsoff_trace_open,
        .close          = irqsoff_trace_close,
-       .use_max_tr     = 1,
+       .use_max_tr     = true,
 };
 # define register_irqsoff(trace) register_tracer(&trace)
 #else
@@ -637,7 +637,7 @@ static struct tracer preemptoff_tracer __read_mostly =
        .reset          = irqsoff_tracer_reset,
        .start          = irqsoff_tracer_start,
        .stop           = irqsoff_tracer_stop,
-       .print_max      = 1,
+       .print_max      = true,
        .print_header   = irqsoff_print_header,
        .print_line     = irqsoff_print_line,
        .flags          = &tracer_flags,
@@ -647,7 +647,7 @@ static struct tracer preemptoff_tracer __read_mostly =
 #endif
        .open           = irqsoff_trace_open,
        .close          = irqsoff_trace_close,
-       .use_max_tr     = 1,
+       .use_max_tr     = true,
 };
 # define register_preemptoff(trace) register_tracer(&trace)
 #else
@@ -672,7 +672,7 @@ static struct tracer preemptirqsoff_tracer __read_mostly =
        .reset          = irqsoff_tracer_reset,
        .start          = irqsoff_tracer_start,
        .stop           = irqsoff_tracer_stop,
-       .print_max      = 1,
+       .print_max      = true,
        .print_header   = irqsoff_print_header,
        .print_line     = irqsoff_print_line,
        .flags          = &tracer_flags,
@@ -682,7 +682,7 @@ static struct tracer preemptirqsoff_tracer __read_mostly =
 #endif
        .open           = irqsoff_trace_open,
        .close          = irqsoff_trace_close,
-       .use_max_tr     = 1,
+       .use_max_tr     = true,
 };
 
 # define register_preemptirqsoff(trace) register_tracer(&trace)
@@ -698,4 +698,4 @@ __init static int init_irqsoff_tracer(void)
 
        return 0;
 }
-device_initcall(init_irqsoff_tracer);
+core_initcall(init_irqsoff_tracer);
index 1a21170..1865d5f 100644 (file)
@@ -444,7 +444,7 @@ static int create_trace_probe(int argc, char **argv)
                        return -EINVAL;
                }
                /* an address specified */
-               ret = strict_strtoul(&argv[1][0], 0, (unsigned long *)&addr);
+               ret = kstrtoul(&argv[1][0], 0, (unsigned long *)&addr);
                if (ret) {
                        pr_info("Failed to parse address.\n");
                        return ret;
@@ -751,8 +751,8 @@ static __kprobes void kprobe_trace_func(struct kprobe *kp, struct pt_regs *regs)
        store_trace_args(sizeof(*entry), tp, regs, (u8 *)&entry[1], dsize);
 
        if (!filter_current_check_discard(buffer, call, entry, event))
-               trace_nowake_buffer_unlock_commit_regs(buffer, event,
-                                                      irq_flags, pc, regs);
+               trace_buffer_unlock_commit_regs(buffer, event,
+                                               irq_flags, pc, regs);
 }
 
 /* Kretprobe handler */
@@ -784,8 +784,8 @@ static __kprobes void kretprobe_trace_func(struct kretprobe_instance *ri,
        store_trace_args(sizeof(*entry), tp, regs, (u8 *)&entry[1], dsize);
 
        if (!filter_current_check_discard(buffer, call, entry, event))
-               trace_nowake_buffer_unlock_commit_regs(buffer, event,
-                                                      irq_flags, pc, regs);
+               trace_buffer_unlock_commit_regs(buffer, event,
+                                               irq_flags, pc, regs);
 }
 
 /* Event entry printers */
index 123b189..194d796 100644 (file)
@@ -610,24 +610,54 @@ lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu)
        return trace_print_lat_fmt(s, entry);
 }
 
-static unsigned long preempt_mark_thresh = 100;
+static unsigned long preempt_mark_thresh_us = 100;
 
 static int
-lat_print_timestamp(struct trace_seq *s, u64 abs_usecs,
-                   unsigned long rel_usecs)
+lat_print_timestamp(struct trace_iterator *iter, u64 next_ts)
 {
-       return trace_seq_printf(s, " %4lldus%c: ", abs_usecs,
-                               rel_usecs > preempt_mark_thresh ? '!' :
-                                 rel_usecs > 1 ? '+' : ' ');
+       unsigned long verbose = trace_flags & TRACE_ITER_VERBOSE;
+       unsigned long in_ns = iter->iter_flags & TRACE_FILE_TIME_IN_NS;
+       unsigned long long abs_ts = iter->ts - iter->tr->time_start;
+       unsigned long long rel_ts = next_ts - iter->ts;
+       struct trace_seq *s = &iter->seq;
+
+       if (in_ns) {
+               abs_ts = ns2usecs(abs_ts);
+               rel_ts = ns2usecs(rel_ts);
+       }
+
+       if (verbose && in_ns) {
+               unsigned long abs_usec = do_div(abs_ts, USEC_PER_MSEC);
+               unsigned long abs_msec = (unsigned long)abs_ts;
+               unsigned long rel_usec = do_div(rel_ts, USEC_PER_MSEC);
+               unsigned long rel_msec = (unsigned long)rel_ts;
+
+               return trace_seq_printf(
+                               s, "[%08llx] %ld.%03ldms (+%ld.%03ldms): ",
+                               ns2usecs(iter->ts),
+                               abs_msec, abs_usec,
+                               rel_msec, rel_usec);
+       } else if (verbose && !in_ns) {
+               return trace_seq_printf(
+                               s, "[%016llx] %lld (+%lld): ",
+                               iter->ts, abs_ts, rel_ts);
+       } else if (!verbose && in_ns) {
+               return trace_seq_printf(
+                               s, " %4lldus%c: ",
+                               abs_ts,
+                               rel_ts > preempt_mark_thresh_us ? '!' :
+                                 rel_ts > 1 ? '+' : ' ');
+       } else { /* !verbose && !in_ns */
+               return trace_seq_printf(s, " %4lld: ", abs_ts);
+       }
 }
 
 int trace_print_context(struct trace_iterator *iter)
 {
        struct trace_seq *s = &iter->seq;
        struct trace_entry *entry = iter->ent;
-       unsigned long long t = ns2usecs(iter->ts);
-       unsigned long usec_rem = do_div(t, USEC_PER_SEC);
-       unsigned long secs = (unsigned long)t;
+       unsigned long long t;
+       unsigned long secs, usec_rem;
        char comm[TASK_COMM_LEN];
        int ret;
 
@@ -644,8 +674,13 @@ int trace_print_context(struct trace_iterator *iter)
                        return 0;
        }
 
-       return trace_seq_printf(s, " %5lu.%06lu: ",
-                               secs, usec_rem);
+       if (iter->iter_flags & TRACE_FILE_TIME_IN_NS) {
+               t = ns2usecs(iter->ts);
+               usec_rem = do_div(t, USEC_PER_SEC);
+               secs = (unsigned long)t;
+               return trace_seq_printf(s, " %5lu.%06lu: ", secs, usec_rem);
+       } else
+               return trace_seq_printf(s, " %12llu: ", iter->ts);
 }
 
 int trace_print_lat_context(struct trace_iterator *iter)
@@ -659,36 +694,29 @@ int trace_print_lat_context(struct trace_iterator *iter)
                           *next_entry = trace_find_next_entry(iter, NULL,
                                                               &next_ts);
        unsigned long verbose = (trace_flags & TRACE_ITER_VERBOSE);
-       unsigned long abs_usecs = ns2usecs(iter->ts - iter->tr->time_start);
-       unsigned long rel_usecs;
 
        /* Restore the original ent_size */
        iter->ent_size = ent_size;
 
        if (!next_entry)
                next_ts = iter->ts;
-       rel_usecs = ns2usecs(next_ts - iter->ts);
 
        if (verbose) {
                char comm[TASK_COMM_LEN];
 
                trace_find_cmdline(entry->pid, comm);
 
-               ret = trace_seq_printf(s, "%16s %5d %3d %d %08x %08lx [%08llx]"
-                                      " %ld.%03ldms (+%ld.%03ldms): ", comm,
-                                      entry->pid, iter->cpu, entry->flags,
-                                      entry->preempt_count, iter->idx,
-                                      ns2usecs(iter->ts),
-                                      abs_usecs / USEC_PER_MSEC,
-                                      abs_usecs % USEC_PER_MSEC,
-                                      rel_usecs / USEC_PER_MSEC,
-                                      rel_usecs % USEC_PER_MSEC);
+               ret = trace_seq_printf(
+                               s, "%16s %5d %3d %d %08x %08lx ",
+                               comm, entry->pid, iter->cpu, entry->flags,
+                               entry->preempt_count, iter->idx);
        } else {
                ret = lat_print_generic(s, entry, iter->cpu);
-               if (ret)
-                       ret = lat_print_timestamp(s, abs_usecs, rel_usecs);
        }
 
+       if (ret)
+               ret = lat_print_timestamp(iter, next_ts);
+
        return ret;
 }
 
index daa9980..412e959 100644 (file)
@@ -441,7 +441,7 @@ static const struct fetch_type *find_fetch_type(const char *type)
                        goto fail;
 
                type++;
-               if (strict_strtoul(type, 0, &bs))
+               if (kstrtoul(type, 0, &bs))
                        goto fail;
 
                switch (bs) {
@@ -501,8 +501,8 @@ int traceprobe_split_symbol_offset(char *symbol, unsigned long *offset)
 
        tmp = strchr(symbol, '+');
        if (tmp) {
-               /* skip sign because strict_strtol doesn't accept '+' */
-               ret = strict_strtoul(tmp + 1, 0, offset);
+               /* skip sign because kstrtoul doesn't accept '+' */
+               ret = kstrtoul(tmp + 1, 0, offset);
                if (ret)
                        return ret;
 
@@ -533,7 +533,7 @@ static int parse_probe_vars(char *arg, const struct fetch_type *t,
                        else
                                ret = -EINVAL;
                } else if (isdigit(arg[5])) {
-                       ret = strict_strtoul(arg + 5, 10, &param);
+                       ret = kstrtoul(arg + 5, 10, &param);
                        if (ret || param > PARAM_MAX_STACK)
                                ret = -EINVAL;
                        else {
@@ -579,7 +579,7 @@ static int parse_probe_arg(char *arg, const struct fetch_type *t,
 
        case '@':       /* memory or symbol */
                if (isdigit(arg[1])) {
-                       ret = strict_strtoul(arg + 1, 0, &param);
+                       ret = kstrtoul(arg + 1, 0, &param);
                        if (ret)
                                break;
 
@@ -597,14 +597,14 @@ static int parse_probe_arg(char *arg, const struct fetch_type *t,
                break;
 
        case '+':       /* deref memory */
-               arg++;  /* Skip '+', because strict_strtol() rejects it. */
+               arg++;  /* Skip '+', because kstrtol() rejects it. */
        case '-':
                tmp = strchr(arg, '(');
                if (!tmp)
                        break;
 
                *tmp = '\0';
-               ret = strict_strtol(arg, 0, &offset);
+               ret = kstrtol(arg, 0, &offset);
 
                if (ret)
                        break;
index 7e62c0a..3374c79 100644 (file)
@@ -102,9 +102,7 @@ tracing_sched_wakeup_trace(struct trace_array *tr,
        entry->next_cpu                 = task_cpu(wakee);
 
        if (!filter_check_discard(call, entry, buffer, event))
-               ring_buffer_unlock_commit(buffer, event);
-       ftrace_trace_stack(tr->buffer, flags, 6, pc);
-       ftrace_trace_userstack(tr->buffer, flags, pc);
+               trace_buffer_unlock_commit(buffer, event, flags, pc);
 }
 
 static void
index 02170c0..bc64fc1 100644 (file)
@@ -589,7 +589,7 @@ static struct tracer wakeup_tracer __read_mostly =
        .reset          = wakeup_tracer_reset,
        .start          = wakeup_tracer_start,
        .stop           = wakeup_tracer_stop,
-       .print_max      = 1,
+       .print_max      = true,
        .print_header   = wakeup_print_header,
        .print_line     = wakeup_print_line,
        .flags          = &tracer_flags,
@@ -599,7 +599,7 @@ static struct tracer wakeup_tracer __read_mostly =
 #endif
        .open           = wakeup_trace_open,
        .close          = wakeup_trace_close,
-       .use_max_tr     = 1,
+       .use_max_tr     = true,
 };
 
 static struct tracer wakeup_rt_tracer __read_mostly =
@@ -610,7 +610,7 @@ static struct tracer wakeup_rt_tracer __read_mostly =
        .start          = wakeup_tracer_start,
        .stop           = wakeup_tracer_stop,
        .wait_pipe      = poll_wait_pipe,
-       .print_max      = 1,
+       .print_max      = true,
        .print_header   = wakeup_print_header,
        .print_line     = wakeup_print_line,
        .flags          = &tracer_flags,
@@ -620,7 +620,7 @@ static struct tracer wakeup_rt_tracer __read_mostly =
 #endif
        .open           = wakeup_trace_open,
        .close          = wakeup_trace_close,
-       .use_max_tr     = 1,
+       .use_max_tr     = true,
 };
 
 __init static int init_wakeup_tracer(void)
@@ -637,4 +637,4 @@ __init static int init_wakeup_tracer(void)
 
        return 0;
 }
-device_initcall(init_wakeup_tracer);
+core_initcall(init_wakeup_tracer);
index 2c00a69..4762316 100644 (file)
@@ -320,7 +320,6 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
                                           int (*func)(void))
 {
        int save_ftrace_enabled = ftrace_enabled;
-       int save_tracer_enabled = tracer_enabled;
        unsigned long count;
        char *func_name;
        int ret;
@@ -331,7 +330,6 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
 
        /* enable tracing, and record the filter function */
        ftrace_enabled = 1;
-       tracer_enabled = 1;
 
        /* passed in by parameter to fool gcc from optimizing */
        func();
@@ -395,7 +393,6 @@ int trace_selftest_startup_dynamic_tracing(struct tracer *trace,
 
  out:
        ftrace_enabled = save_ftrace_enabled;
-       tracer_enabled = save_tracer_enabled;
 
        /* Enable tracing on all functions again */
        ftrace_set_global_filter(NULL, 0, 1);
@@ -452,7 +449,6 @@ static int
 trace_selftest_function_recursion(void)
 {
        int save_ftrace_enabled = ftrace_enabled;
-       int save_tracer_enabled = tracer_enabled;
        char *func_name;
        int len;
        int ret;
@@ -465,7 +461,6 @@ trace_selftest_function_recursion(void)
 
        /* enable tracing, and record the filter function */
        ftrace_enabled = 1;
-       tracer_enabled = 1;
 
        /* Handle PPC64 '.' name */
        func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
@@ -534,7 +529,6 @@ trace_selftest_function_recursion(void)
        ret = 0;
 out:
        ftrace_enabled = save_ftrace_enabled;
-       tracer_enabled = save_tracer_enabled;
 
        return ret;
 }
@@ -569,7 +563,6 @@ static int
 trace_selftest_function_regs(void)
 {
        int save_ftrace_enabled = ftrace_enabled;
-       int save_tracer_enabled = tracer_enabled;
        char *func_name;
        int len;
        int ret;
@@ -586,7 +579,6 @@ trace_selftest_function_regs(void)
 
        /* enable tracing, and record the filter function */
        ftrace_enabled = 1;
-       tracer_enabled = 1;
 
        /* Handle PPC64 '.' name */
        func_name = "*" __stringify(DYN_FTRACE_TEST_NAME);
@@ -648,7 +640,6 @@ trace_selftest_function_regs(void)
        ret = 0;
 out:
        ftrace_enabled = save_ftrace_enabled;
-       tracer_enabled = save_tracer_enabled;
 
        return ret;
 }
@@ -662,7 +653,6 @@ int
 trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
 {
        int save_ftrace_enabled = ftrace_enabled;
-       int save_tracer_enabled = tracer_enabled;
        unsigned long count;
        int ret;
 
@@ -671,7 +661,6 @@ trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
 
        /* start the tracing */
        ftrace_enabled = 1;
-       tracer_enabled = 1;
 
        ret = tracer_init(trace, tr);
        if (ret) {
@@ -708,7 +697,6 @@ trace_selftest_startup_function(struct tracer *trace, struct trace_array *tr)
        ret = trace_selftest_function_regs();
  out:
        ftrace_enabled = save_ftrace_enabled;
-       tracer_enabled = save_tracer_enabled;
 
        /* kill ftrace totally if we failed */
        if (ret)
@@ -1106,6 +1094,7 @@ trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)
        tracing_stop();
        /* check both trace buffers */
        ret = trace_test_buffer(tr, NULL);
+       printk("ret = %d\n", ret);
        if (!ret)
                ret = trace_test_buffer(&max_tr, &count);
 
index 2485a7d..7609dd6 100644 (file)
@@ -21,9 +21,6 @@ static int syscall_enter_register(struct ftrace_event_call *event,
 static int syscall_exit_register(struct ftrace_event_call *event,
                                 enum trace_reg type, void *data);
 
-static int syscall_enter_define_fields(struct ftrace_event_call *call);
-static int syscall_exit_define_fields(struct ftrace_event_call *call);
-
 static struct list_head *
 syscall_get_enter_fields(struct ftrace_event_call *call)
 {
@@ -32,30 +29,6 @@ syscall_get_enter_fields(struct ftrace_event_call *call)
        return &entry->enter_fields;
 }
 
-struct trace_event_functions enter_syscall_print_funcs = {
-       .trace          = print_syscall_enter,
-};
-
-struct trace_event_functions exit_syscall_print_funcs = {
-       .trace          = print_syscall_exit,
-};
-
-struct ftrace_event_class event_class_syscall_enter = {
-       .system         = "syscalls",
-       .reg            = syscall_enter_register,
-       .define_fields  = syscall_enter_define_fields,
-       .get_fields     = syscall_get_enter_fields,
-       .raw_init       = init_syscall_trace,
-};
-
-struct ftrace_event_class event_class_syscall_exit = {
-       .system         = "syscalls",
-       .reg            = syscall_exit_register,
-       .define_fields  = syscall_exit_define_fields,
-       .fields         = LIST_HEAD_INIT(event_class_syscall_exit.fields),
-       .raw_init       = init_syscall_trace,
-};
-
 extern struct syscall_metadata *__start_syscalls_metadata[];
 extern struct syscall_metadata *__stop_syscalls_metadata[];
 
@@ -432,7 +405,7 @@ void unreg_event_syscall_exit(struct ftrace_event_call *call)
        mutex_unlock(&syscall_trace_lock);
 }
 
-int init_syscall_trace(struct ftrace_event_call *call)
+static int init_syscall_trace(struct ftrace_event_call *call)
 {
        int id;
        int num;
@@ -457,6 +430,30 @@ int init_syscall_trace(struct ftrace_event_call *call)
        return id;
 }
 
+struct trace_event_functions enter_syscall_print_funcs = {
+       .trace          = print_syscall_enter,
+};
+
+struct trace_event_functions exit_syscall_print_funcs = {
+       .trace          = print_syscall_exit,
+};
+
+struct ftrace_event_class event_class_syscall_enter = {
+       .system         = "syscalls",
+       .reg            = syscall_enter_register,
+       .define_fields  = syscall_enter_define_fields,
+       .get_fields     = syscall_get_enter_fields,
+       .raw_init       = init_syscall_trace,
+};
+
+struct ftrace_event_class event_class_syscall_exit = {
+       .system         = "syscalls",
+       .reg            = syscall_exit_register,
+       .define_fields  = syscall_exit_define_fields,
+       .fields         = LIST_HEAD_INIT(event_class_syscall_exit.fields),
+       .raw_init       = init_syscall_trace,
+};
+
 unsigned long __init __weak arch_syscall_addr(int nr)
 {
        return (unsigned long)sys_call_table[nr];
@@ -537,7 +534,7 @@ static void perf_syscall_enter(void *ignore, struct pt_regs *regs, long id)
        perf_trace_buf_submit(rec, size, rctx, 0, 1, regs, head, NULL);
 }
 
-int perf_sysenter_enable(struct ftrace_event_call *call)
+static int perf_sysenter_enable(struct ftrace_event_call *call)
 {
        int ret = 0;
        int num;
@@ -558,7 +555,7 @@ int perf_sysenter_enable(struct ftrace_event_call *call)
        return ret;
 }
 
-void perf_sysenter_disable(struct ftrace_event_call *call)
+static void perf_sysenter_disable(struct ftrace_event_call *call)
 {
        int num;
 
@@ -615,7 +612,7 @@ static void perf_syscall_exit(void *ignore, struct pt_regs *regs, long ret)
        perf_trace_buf_submit(rec, size, rctx, 0, 1, regs, head, NULL);
 }
 
-int perf_sysexit_enable(struct ftrace_event_call *call)
+static int perf_sysexit_enable(struct ftrace_event_call *call)
 {
        int ret = 0;
        int num;
@@ -636,7 +633,7 @@ int perf_sysexit_enable(struct ftrace_event_call *call)
        return ret;
 }
 
-void perf_sysexit_disable(struct ftrace_event_call *call)
+static void perf_sysexit_disable(struct ftrace_event_call *call)
 {
        int num;
 
index 03003cd..9614db8 100644 (file)
@@ -189,7 +189,7 @@ static int create_trace_uprobe(int argc, char **argv)
        if (argv[0][0] == '-')
                is_delete = true;
        else if (argv[0][0] != 'p') {
-               pr_info("Probe definition must be started with 'p', 'r' or" " '-'.\n");
+               pr_info("Probe definition must be started with 'p' or '-'.\n");
                return -EINVAL;
        }
 
@@ -252,7 +252,7 @@ static int create_trace_uprobe(int argc, char **argv)
        if (ret)
                goto fail_address_parse;
 
-       ret = strict_strtoul(arg, 0, &offset);
+       ret = kstrtoul(arg, 0, &offset);
        if (ret)
                goto fail_address_parse;
 
index 04d959f..a20e320 100644 (file)
@@ -253,7 +253,7 @@ all_deps := $(all_objs:%.o=.%.d)
 # let .d file also depends on the source and header files
 define check_deps
                @set -e; $(RM) $@; \
-               $(CC) -M $(CFLAGS) $< > $@.$$$$; \
+               $(CC) -MM $(CFLAGS) $< > $@.$$$$; \
                sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \
                $(RM) $@.$$$$
 endef
index f2989c5..5a824e3 100644 (file)
@@ -174,7 +174,7 @@ static int cmdline_init(struct pevent *pevent)
        return 0;
 }
 
-static char *find_cmdline(struct pevent *pevent, int pid)
+static const char *find_cmdline(struct pevent *pevent, int pid)
 {
        const struct cmdline *comm;
        struct cmdline key;
@@ -2637,7 +2637,7 @@ process_func_handler(struct event_format *event, struct pevent_function_handler
        struct print_arg *farg;
        enum event_type type;
        char *token;
-       char *test;
+       const char *test;
        int i;
 
        arg->type = PRINT_FUNC;
@@ -3889,7 +3889,7 @@ static void print_mac_arg(struct trace_seq *s, int mac, void *data, int size,
                          struct event_format *event, struct print_arg *arg)
 {
        unsigned char *buf;
-       char *fmt = "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x";
+       const char *fmt = "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x";
 
        if (arg->type == PRINT_FUNC) {
                process_defined_func(s, data, size, event, arg);
@@ -3931,7 +3931,8 @@ static int is_printable_array(char *p, unsigned int len)
        return 1;
 }
 
-static void print_event_fields(struct trace_seq *s, void *data, int size,
+static void print_event_fields(struct trace_seq *s, void *data,
+                              int size __maybe_unused,
                               struct event_format *event)
 {
        struct format_field *field;
@@ -4408,7 +4409,7 @@ void pevent_event_info(struct trace_seq *s, struct event_format *event,
 void pevent_print_event(struct pevent *pevent, struct trace_seq *s,
                        struct pevent_record *record)
 {
-       static char *spaces = "                    "; /* 20 spaces */
+       static const char *spaces = "                    "; /* 20 spaces */
        struct event_format *event;
        unsigned long secs;
        unsigned long usecs;
@@ -5070,8 +5071,8 @@ static const char * const pevent_error_str[] = {
 };
 #undef _PE
 
-int pevent_strerror(struct pevent *pevent, enum pevent_errno errnum,
-                   char *buf, size_t buflen)
+int pevent_strerror(struct pevent *pevent __maybe_unused,
+                   enum pevent_errno errnum, char *buf, size_t buflen)
 {
        int idx;
        const char *msg;
@@ -5100,6 +5101,7 @@ int pevent_strerror(struct pevent *pevent, enum pevent_errno errnum,
        case PEVENT_ERRNO__READ_FORMAT_FAILED:
        case PEVENT_ERRNO__READ_PRINT_FAILED:
        case PEVENT_ERRNO__OLD_FTRACE_ARG_FAILED:
+       case PEVENT_ERRNO__INVALID_ARG_TYPE:
                snprintf(buf, buflen, "%s", msg);
                break;
 
@@ -5362,7 +5364,7 @@ int pevent_register_print_function(struct pevent *pevent,
                if (type == PEVENT_FUNC_ARG_VOID)
                        break;
 
-               if (type < 0 || type >= PEVENT_FUNC_ARG_MAX_TYPES) {
+               if (type >= PEVENT_FUNC_ARG_MAX_TYPES) {
                        do_warning("Invalid argument type %d", type);
                        ret = PEVENT_ERRNO__INVALID_ARG_TYPE;
                        goto out_free;
@@ -5560,7 +5562,7 @@ void pevent_free(struct pevent *pevent)
        }
 
        if (pevent->func_map) {
-               for (i = 0; i < pevent->func_count; i++) {
+               for (i = 0; i < (int)pevent->func_count; i++) {
                        free(pevent->func_map[i].func);
                        free(pevent->func_map[i].mod);
                }
@@ -5582,7 +5584,7 @@ void pevent_free(struct pevent *pevent)
        }
 
        if (pevent->printk_map) {
-               for (i = 0; i < pevent->printk_count; i++)
+               for (i = 0; i < (int)pevent->printk_count; i++)
                        free(pevent->printk_map[i].printk);
                free(pevent->printk_map);
        }
index 9f2e44f..ef6d22e 100644 (file)
@@ -1,3 +1,5 @@
+include ../config/utilities.mak
+
 OUTPUT := ./
 ifeq ("$(origin O)", "command line")
   ifneq ($(O),)
@@ -64,6 +66,7 @@ MAKEINFO=makeinfo
 INSTALL_INFO=install-info
 DOCBOOK2X_TEXI=docbook2x-texi
 DBLATEX=dblatex
+XMLTO=xmlto
 ifndef PERL_PATH
        PERL_PATH = /usr/bin/perl
 endif
@@ -71,6 +74,16 @@ endif
 -include ../config.mak.autogen
 -include ../config.mak
 
+_tmp_tool_path := $(call get-executable,$(ASCIIDOC))
+ifeq ($(_tmp_tool_path),)
+       missing_tools = $(ASCIIDOC)
+endif
+
+_tmp_tool_path := $(call get-executable,$(XMLTO))
+ifeq ($(_tmp_tool_path),)
+       missing_tools += $(XMLTO)
+endif
+
 #
 # For asciidoc ...
 #      -7.1.2, no extra settings are needed.
@@ -170,7 +183,12 @@ pdf: $(OUTPUT)user-manual.pdf
 
 install: install-man
 
-install-man: man
+check-man-tools:
+ifdef missing_tools
+       $(error "You need to install $(missing_tools) for man pages")
+endif
+
+do-install-man: man
        $(INSTALL) -d -m 755 $(DESTDIR)$(man1dir)
 #      $(INSTALL) -d -m 755 $(DESTDIR)$(man5dir)
 #      $(INSTALL) -d -m 755 $(DESTDIR)$(man7dir)
@@ -178,6 +196,15 @@ install-man: man
 #      $(INSTALL) -m 644 $(DOC_MAN5) $(DESTDIR)$(man5dir)
 #      $(INSTALL) -m 644 $(DOC_MAN7) $(DESTDIR)$(man7dir)
 
+install-man: check-man-tools man
+
+try-install-man:
+ifdef missing_tools
+       $(warning Please install $(missing_tools) to have the man pages installed)
+else
+       $(MAKE) do-install-man
+endif
+
 install-info: info
        $(INSTALL) -d -m 755 $(DESTDIR)$(infodir)
        $(INSTALL) -m 644 $(OUTPUT)perf.info $(OUTPUT)perfman.info $(DESTDIR)$(infodir)
@@ -246,7 +273,7 @@ $(MAN_HTML): $(OUTPUT)%.html : %.txt
 
 $(OUTPUT)%.1 $(OUTPUT)%.5 $(OUTPUT)%.7 : $(OUTPUT)%.xml
        $(QUIET_XMLTO)$(RM) $@ && \
-       xmlto -o $(OUTPUT) -m $(MANPAGE_XSL) $(XMLTO_EXTRA) man $<
+       $(XMLTO) -o $(OUTPUT) -m $(MANPAGE_XSL) $(XMLTO_EXTRA) man $<
 
 $(OUTPUT)%.xml : %.txt
        $(QUIET_ASCIIDOC)$(RM) $@+ $@ && \
diff --git a/tools/perf/Documentation/android.txt b/tools/perf/Documentation/android.txt
new file mode 100644 (file)
index 0000000..8484c3a
--- /dev/null
@@ -0,0 +1,78 @@
+How to compile perf for Android
+=========================================
+
+I. Set the Android NDK environment
+------------------------------------------------
+
+(a). Use the Android NDK
+------------------------------------------------
+1. You need to download and install the Android Native Development Kit (NDK).
+Set the NDK variable to point to the path where you installed the NDK:
+  export NDK=/path/to/android-ndk
+
+2. Set cross-compiling environment variables for NDK toolchain and sysroot.
+For arm:
+  export NDK_TOOLCHAIN=${NDK}/toolchains/arm-linux-androideabi-4.6/prebuilt/linux-x86/bin/arm-linux-androideabi-
+  export NDK_SYSROOT=${NDK}/platforms/android-9/arch-arm
+For x86:
+  export NDK_TOOLCHAIN=${NDK}/toolchains/x86-4.6/prebuilt/linux-x86/bin/i686-linux-android-
+  export NDK_SYSROOT=${NDK}/platforms/android-9/arch-x86
+
+This method is not working for Android NDK versions up to Revision 8b.
+perf uses some bionic enhancements that are not included in these NDK versions.
+You can use method (b) described below instead.
+
+(b). Use the Android source tree
+-----------------------------------------------
+1. Download the master branch of the Android source tree.
+Set the environment for the target you want using:
+  source build/envsetup.sh
+  lunch
+
+2. Build your own NDK sysroot to contain latest bionic changes and set the
+NDK sysroot environment variable.
+  cd ${ANDROID_BUILD_TOP}/ndk
+For arm:
+  ./build/tools/build-ndk-sysroot.sh --abi=arm
+  export NDK_SYSROOT=${ANDROID_BUILD_TOP}/ndk/build/platforms/android-3/arch-arm
+For x86:
+  ./build/tools/build-ndk-sysroot.sh --abi=x86
+  export NDK_SYSROOT=${ANDROID_BUILD_TOP}/ndk/build/platforms/android-3/arch-x86
+
+3. Set the NDK toolchain environment variable.
+For arm:
+  export NDK_TOOLCHAIN=${ANDROID_TOOLCHAIN}/arm-linux-androideabi-
+For x86:
+  export NDK_TOOLCHAIN=${ANDROID_TOOLCHAIN}/i686-linux-android-
+
+II. Compile perf for Android
+------------------------------------------------
+You need to run make with the NDK toolchain and sysroot defined above:
+For arm:
+  make ARCH=arm CROSS_COMPILE=${NDK_TOOLCHAIN} CFLAGS="--sysroot=${NDK_SYSROOT}"
+For x86:
+  make ARCH=x86 CROSS_COMPILE=${NDK_TOOLCHAIN} CFLAGS="--sysroot=${NDK_SYSROOT}"
+
+III. Install perf
+-----------------------------------------------
+You need to connect to your Android device/emulator using adb.
+Install perf using:
+  adb push perf /data/perf
+
+If you also want to use perf-archive you need busybox tools for Android.
+For installing perf-archive, you first need to replace #!/bin/bash with #!/system/bin/sh:
+  sed 's/#!\/bin\/bash/#!\/system\/bin\/sh/g' perf-archive >> /tmp/perf-archive
+  chmod +x /tmp/perf-archive
+  adb push /tmp/perf-archive /data/perf-archive
+
+IV. Environment settings for running perf
+------------------------------------------------
+Some perf features need environment variables to run properly.
+You need to set these before running perf on the target:
+  adb shell
+  # PERF_PAGER=cat
+
+IV. Run perf
+------------------------------------------------
+Run perf on your device/emulator to which you previously connected using adb:
+  # ./data/perf
index ab7f667..194f37d 100644 (file)
@@ -72,6 +72,66 @@ OPTIONS
 --symfs=<directory>::
         Look for files with symbols relative to this directory.
 
+-b::
+--baseline-only::
+        Show only items with match in baseline.
+
+-c::
+--compute::
+        Differential computation selection - delta,ratio,wdiff (default is delta).
+        If '+' is specified as a first character, the output is sorted based
+        on the computation results.
+        See COMPARISON METHODS section for more info.
+
+-p::
+--period::
+        Show period values for both compared hist entries.
+
+-F::
+--formula::
+        Show formula for given computation.
+
+COMPARISON METHODS
+------------------
+delta
+~~~~~
+If specified the 'Delta' column is displayed with value 'd' computed as:
+
+  d = A->period_percent - B->period_percent
+
+with:
+  - A/B being matching hist entry from first/second file specified
+    (or perf.data/perf.data.old) respectively.
+
+  - period_percent being the % of the hist entry period value within
+    single data file
+
+ratio
+~~~~~
+If specified the 'Ratio' column is displayed with value 'r' computed as:
+
+  r = A->period / B->period
+
+with:
+  - A/B being matching hist entry from first/second file specified
+    (or perf.data/perf.data.old) respectively.
+
+  - period being the hist entry period value
+
+wdiff
+~~~~~
+If specified the 'Weighted diff' column is displayed with value 'd' computed as:
+
+   d = B->period * WEIGHT-A - A->period * WEIGHT-B
+
+  - A/B being matching hist entry from first/second file specified
+    (or perf.data/perf.data.old) respectively.
+
+  - period being the hist entry period value
+
+  - WEIGHT-A/WEIGHT-B being user suplied weights in the the '-c' option
+    behind ':' separator like '-c wdiff:1,2'.
+
 SEE ALSO
 --------
 linkperf:perf-record[1]
index 025630d..a00a342 100644 (file)
@@ -29,6 +29,17 @@ OPTIONS
 -v::
 --verbose::
        Be more verbose.
+-i::
+--input=::
+       Input file name. (default: stdin)
+-o::
+--output=::
+       Output file name. (default: stdout)
+-s::
+--sched-stat::
+       Merge sched_stat and sched_switch for getting events where and how long
+       tasks slept. sched_switch contains a callchain where a task slept and
+       sched_stat contains a timeslice how long a task slept.
 
 SEE ALSO
 --------
index 2fa173b..cf0c310 100644 (file)
@@ -108,6 +108,11 @@ with it.  --append may be used here.  Examples:
      3>results  perf stat --log-fd 3          -- $cmd
      3>>results perf stat --log-fd 3 --append -- $cmd
 
+--pre::
+--post::
+       Pre and post measurement hooks, e.g.:
+
+perf stat --repeat 10 --null --sync --pre 'make -s O=defconfig-build/clean' -- make -s -j64 O=defconfig-build/ bzImage
 
 
 EXAMPLES
index 3a2ae37..68718cc 100644 (file)
@@ -48,6 +48,12 @@ comma-separated list with no space: 0,1. Ranges of CPUs are specified with -: 0-
 In per-thread mode with inheritance mode on (default), Events are captured only when
 the thread executes on the designated CPUs. Default is to monitor all CPUs.
 
+--duration:
+       Show only events that had a duration greater than N.M ms.
+
+--sched:
+       Accrue thread runtime and provide a summary at the end of the session.
+
 SEE ALSO
 --------
 linkperf:perf-record[1], linkperf:perf-script[1]
index 0a619af..891bc77 100644 (file)
@@ -155,15 +155,15 @@ SPARSE_FLAGS = -D__BIG_ENDIAN__ -D__powerpc__
 
 -include config/feature-tests.mak
 
-ifeq ($(call try-cc,$(SOURCE_HELLO),-Werror -fstack-protector-all),y)
+ifeq ($(call try-cc,$(SOURCE_HELLO),$(CFLAGS) -Werror -fstack-protector-all,-fstack-protector-all),y)
        CFLAGS := $(CFLAGS) -fstack-protector-all
 endif
 
-ifeq ($(call try-cc,$(SOURCE_HELLO),-Werror -Wstack-protector),y)
+ifeq ($(call try-cc,$(SOURCE_HELLO),$(CFLAGS) -Werror -Wstack-protector,-Wstack-protector),y)
        CFLAGS := $(CFLAGS) -Wstack-protector
 endif
 
-ifeq ($(call try-cc,$(SOURCE_HELLO),-Werror -Wvolatile-register-var),y)
+ifeq ($(call try-cc,$(SOURCE_HELLO),$(CFLAGS) -Werror -Wvolatile-register-var,-Wvolatile-register-var),y)
        CFLAGS := $(CFLAGS) -Wvolatile-register-var
 endif
 
@@ -197,8 +197,16 @@ BASIC_CFLAGS = \
        -I. \
        -I$(TRACE_EVENT_DIR) \
        -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
+
 BASIC_LDFLAGS =
 
+ifeq ($(call try-cc,$(SOURCE_BIONIC),$(CFLAGS),bionic),y)
+       BIONIC := 1
+       EXTLIBS := $(filter-out -lrt,$(EXTLIBS))
+       EXTLIBS := $(filter-out -lpthread,$(EXTLIBS))
+       BASIC_CFLAGS += -I.
+endif
+
 # Guard against environment variables
 BUILTIN_OBJS =
 LIB_H =
@@ -330,6 +338,7 @@ LIB_H += util/evlist.h
 LIB_H += util/exec_cmd.h
 LIB_H += util/types.h
 LIB_H += util/levenshtein.h
+LIB_H += util/machine.h
 LIB_H += util/map.h
 LIB_H += util/parse-options.h
 LIB_H += util/parse-events.h
@@ -346,6 +355,7 @@ LIB_H += util/svghelper.h
 LIB_H += util/tool.h
 LIB_H += util/run-command.h
 LIB_H += util/sigchain.h
+LIB_H += util/dso.h
 LIB_H += util/symbol.h
 LIB_H += util/color.h
 LIB_H += util/values.h
@@ -389,7 +399,6 @@ 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/parse-events-test.o
 LIB_OBJS += $(OUTPUT)util/path.o
 LIB_OBJS += $(OUTPUT)util/rbtree.o
 LIB_OBJS += $(OUTPUT)util/bitmap.o
@@ -404,15 +413,16 @@ LIB_OBJS += $(OUTPUT)util/top.o
 LIB_OBJS += $(OUTPUT)util/usage.o
 LIB_OBJS += $(OUTPUT)util/wrapper.o
 LIB_OBJS += $(OUTPUT)util/sigchain.o
+LIB_OBJS += $(OUTPUT)util/dso.o
 LIB_OBJS += $(OUTPUT)util/symbol.o
 LIB_OBJS += $(OUTPUT)util/symbol-elf.o
-LIB_OBJS += $(OUTPUT)util/dso-test-data.o
 LIB_OBJS += $(OUTPUT)util/color.o
 LIB_OBJS += $(OUTPUT)util/pager.o
 LIB_OBJS += $(OUTPUT)util/header.o
 LIB_OBJS += $(OUTPUT)util/callchain.o
 LIB_OBJS += $(OUTPUT)util/values.o
 LIB_OBJS += $(OUTPUT)util/debug.o
+LIB_OBJS += $(OUTPUT)util/machine.o
 LIB_OBJS += $(OUTPUT)util/map.o
 LIB_OBJS += $(OUTPUT)util/pstack.o
 LIB_OBJS += $(OUTPUT)util/session.o
@@ -440,10 +450,29 @@ LIB_OBJS += $(OUTPUT)util/intlist.o
 LIB_OBJS += $(OUTPUT)util/vdso.o
 LIB_OBJS += $(OUTPUT)util/stat.o
 
+LIB_OBJS += $(OUTPUT)ui/setup.o
 LIB_OBJS += $(OUTPUT)ui/helpline.o
+LIB_OBJS += $(OUTPUT)ui/progress.o
 LIB_OBJS += $(OUTPUT)ui/hist.o
 LIB_OBJS += $(OUTPUT)ui/stdio/hist.o
 
+LIB_OBJS += $(OUTPUT)arch/common.o
+
+LIB_OBJS += $(OUTPUT)tests/parse-events.o
+LIB_OBJS += $(OUTPUT)tests/dso-data.o
+LIB_OBJS += $(OUTPUT)tests/attr.o
+LIB_OBJS += $(OUTPUT)tests/vmlinux-kallsyms.o
+LIB_OBJS += $(OUTPUT)tests/open-syscall.o
+LIB_OBJS += $(OUTPUT)tests/open-syscall-all-cpus.o
+LIB_OBJS += $(OUTPUT)tests/open-syscall-tp-fields.o
+LIB_OBJS += $(OUTPUT)tests/mmap-basic.o
+LIB_OBJS += $(OUTPUT)tests/perf-record.o
+LIB_OBJS += $(OUTPUT)tests/rdpmc.o
+LIB_OBJS += $(OUTPUT)tests/evsel-roundtrip-name.o
+LIB_OBJS += $(OUTPUT)tests/evsel-tp-sched.o
+LIB_OBJS += $(OUTPUT)tests/pmu.o
+LIB_OBJS += $(OUTPUT)tests/util.o
+
 BUILTIN_OBJS += $(OUTPUT)builtin-annotate.o
 BUILTIN_OBJS += $(OUTPUT)builtin-bench.o
 # Benchmark modules
@@ -473,8 +502,8 @@ 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
+BUILTIN_OBJS += $(OUTPUT)tests/builtin-test.o
 
 PERFLIBS = $(LIB_FILE) $(LIBTRACEEVENT)
 
@@ -495,18 +524,33 @@ ifdef NO_LIBELF
        NO_LIBUNWIND := 1
 else
 FLAGS_LIBELF=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS)
-ifneq ($(call try-cc,$(SOURCE_LIBELF),$(FLAGS_LIBELF)),y)
+ifneq ($(call try-cc,$(SOURCE_LIBELF),$(FLAGS_LIBELF),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
+       ifeq ($(call try-cc,$(SOURCE_GLIBC),$(FLAGS_GLIBC),glibc),y)
+               LIBC_SUPPORT := 1
+       endif
+       ifeq ($(BIONIC),1)
+               LIBC_SUPPORT := 1
+       endif
+       ifeq ($(LIBC_SUPPORT),1)
+               msg := $(warning No libelf found, disables 'probe' tool, please install elfutils-libelf-devel/libelf-dev);
+
                NO_LIBELF := 1
                NO_DWARF := 1
                NO_DEMANGLE := 1
+       else
+               msg := $(error No gnu/libc-version.h found, please install glibc-dev[el]/glibc-static);
        endif
 else
-       FLAGS_DWARF=$(ALL_CFLAGS) -ldw -lelf $(ALL_LDFLAGS) $(EXTLIBS)
-       ifneq ($(call try-cc,$(SOURCE_DWARF),$(FLAGS_DWARF)),y)
+       # for linking with debug library, run like:
+       # make DEBUG=1 LIBDW_DIR=/opt/libdw/
+       ifdef LIBDW_DIR
+               LIBDW_CFLAGS  := -I$(LIBDW_DIR)/include
+               LIBDW_LDFLAGS := -L$(LIBDW_DIR)/lib
+       endif
+
+       FLAGS_DWARF=$(ALL_CFLAGS) $(LIBDW_CFLAGS) -ldw -lelf $(LIBDW_LDFLAGS) $(ALL_LDFLAGS) $(EXTLIBS)
+       ifneq ($(call try-cc,$(SOURCE_DWARF),$(FLAGS_DWARF),libdw),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
@@ -522,7 +566,7 @@ ifdef LIBUNWIND_DIR
 endif
 
 FLAGS_UNWIND=$(LIBUNWIND_CFLAGS) $(ALL_CFLAGS) $(LIBUNWIND_LDFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) $(LIBUNWIND_LIBS)
-ifneq ($(call try-cc,$(SOURCE_LIBUNWIND),$(FLAGS_UNWIND)),y)
+ifneq ($(call try-cc,$(SOURCE_LIBUNWIND),$(FLAGS_UNWIND),libunwind),y)
        msg := $(warning No libunwind found, disabling post unwind support. Please install libunwind-dev[el] >= 0.99);
        NO_LIBUNWIND := 1
 endif # Libunwind support
@@ -551,7 +595,8 @@ LIB_OBJS += $(OUTPUT)util/symbol-minimal.o
 else # NO_LIBELF
 BASIC_CFLAGS += -DLIBELF_SUPPORT
 
-ifeq ($(call try-cc,$(SOURCE_ELF_MMAP),$(FLAGS_COMMON)),y)
+FLAGS_LIBELF=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS)
+ifeq ($(call try-cc,$(SOURCE_ELF_MMAP),$(FLAGS_LIBELF),-DLIBELF_MMAP),y)
        BASIC_CFLAGS += -DLIBELF_MMAP
 endif
 
@@ -559,7 +604,8 @@ 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
+       BASIC_CFLAGS := -DDWARF_SUPPORT $(LIBDW_CFLAGS) $(BASIC_CFLAGS)
+       BASIC_LDFLAGS := $(LIBDW_LDFLAGS) $(BASIC_LDFLAGS)
        EXTLIBS += -lelf -ldw
        LIB_OBJS += $(OUTPUT)util/probe-finder.o
        LIB_OBJS += $(OUTPUT)util/dwarf-aux.o
@@ -577,7 +623,7 @@ endif
 
 ifndef NO_LIBAUDIT
        FLAGS_LIBAUDIT = $(ALL_CFLAGS) $(ALL_LDFLAGS) -laudit
-       ifneq ($(call try-cc,$(SOURCE_LIBAUDIT),$(FLAGS_LIBAUDIT)),y)
+       ifneq ($(call try-cc,$(SOURCE_LIBAUDIT),$(FLAGS_LIBAUDIT),libaudit),y)
                msg := $(warning No libaudit.h found, disables 'trace' tool, please install audit-libs-devel or libaudit-dev);
        else
                BASIC_CFLAGS += -DLIBAUDIT_SUPPORT
@@ -588,23 +634,23 @@ endif
 
 ifndef NO_NEWT
        FLAGS_NEWT=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) -lnewt
-       ifneq ($(call try-cc,$(SOURCE_NEWT),$(FLAGS_NEWT)),y)
+       ifneq ($(call try-cc,$(SOURCE_NEWT),$(FLAGS_NEWT),libnewt),y)
                msg := $(warning newt not found, disables TUI support. Please install newt-devel or libnewt-dev);
        else
                # Fedora has /usr/include/slang/slang.h, but ubuntu /usr/include/slang.h
                BASIC_CFLAGS += -I/usr/include/slang
                BASIC_CFLAGS += -DNEWT_SUPPORT
                EXTLIBS += -lnewt -lslang
-               LIB_OBJS += $(OUTPUT)ui/setup.o
                LIB_OBJS += $(OUTPUT)ui/browser.o
                LIB_OBJS += $(OUTPUT)ui/browsers/annotate.o
                LIB_OBJS += $(OUTPUT)ui/browsers/hists.o
                LIB_OBJS += $(OUTPUT)ui/browsers/map.o
-               LIB_OBJS += $(OUTPUT)ui/progress.o
+               LIB_OBJS += $(OUTPUT)ui/browsers/scripts.o
                LIB_OBJS += $(OUTPUT)ui/util.o
                LIB_OBJS += $(OUTPUT)ui/tui/setup.o
                LIB_OBJS += $(OUTPUT)ui/tui/util.o
                LIB_OBJS += $(OUTPUT)ui/tui/helpline.o
+               LIB_OBJS += $(OUTPUT)ui/tui/progress.o
                LIB_H += ui/browser.h
                LIB_H += ui/browsers/map.h
                LIB_H += ui/keysyms.h
@@ -617,10 +663,10 @@ endif
 
 ifndef NO_GTK2
        FLAGS_GTK2=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) $(shell pkg-config --libs --cflags gtk+-2.0 2>/dev/null)
-       ifneq ($(call try-cc,$(SOURCE_GTK2),$(FLAGS_GTK2)),y)
+       ifneq ($(call try-cc,$(SOURCE_GTK2),$(FLAGS_GTK2),gtk2),y)
                msg := $(warning GTK2 not found, disables GTK2 support. Please install gtk2-devel or libgtk2.0-dev);
        else
-               ifeq ($(call try-cc,$(SOURCE_GTK2_INFOBAR),$(FLAGS_GTK2)),y)
+               ifeq ($(call try-cc,$(SOURCE_GTK2_INFOBAR),$(FLAGS_GTK2),-DHAVE_GTK_INFO_BAR),y)
                        BASIC_CFLAGS += -DHAVE_GTK_INFO_BAR
                endif
                BASIC_CFLAGS += -DGTK2_SUPPORT
@@ -630,9 +676,9 @@ ifndef NO_GTK2
                LIB_OBJS += $(OUTPUT)ui/gtk/setup.o
                LIB_OBJS += $(OUTPUT)ui/gtk/util.o
                LIB_OBJS += $(OUTPUT)ui/gtk/helpline.o
+               LIB_OBJS += $(OUTPUT)ui/gtk/progress.o
                # Make sure that it'd be included only once.
                ifeq ($(findstring -DNEWT_SUPPORT,$(BASIC_CFLAGS)),)
-                       LIB_OBJS += $(OUTPUT)ui/setup.o
                        LIB_OBJS += $(OUTPUT)ui/util.o
                endif
        endif
@@ -647,7 +693,7 @@ else
        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)
+       ifneq ($(call try-cc,$(SOURCE_PERL_EMBED),$(FLAGS_PERL_EMBED),perl),y)
                BASIC_CFLAGS += -DNO_LIBPERL
        else
                ALL_LDFLAGS += $(PERL_EMBED_LDFLAGS)
@@ -701,11 +747,11 @@ else
       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)
+      ifneq ($(call try-cc,$(SOURCE_PYTHON_EMBED),$(FLAGS_PYTHON_EMBED),python),y)
         $(call disable-python,Python.h (for Python 2.x))
       else
 
-        ifneq ($(call try-cc,$(SOURCE_PYTHON_VERSION),$(FLAGS_PYTHON_EMBED)),y)
+        ifneq ($(call try-cc,$(SOURCE_PYTHON_VERSION),$(FLAGS_PYTHON_EMBED),python version),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)
@@ -739,22 +785,22 @@ else
                BASIC_CFLAGS += -DHAVE_CPLUS_DEMANGLE
         else
                FLAGS_BFD=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) -DPACKAGE='perf' -lbfd
-               has_bfd := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD))
+               has_bfd := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD),libbfd)
                ifeq ($(has_bfd),y)
                        EXTLIBS += -lbfd
                else
                        FLAGS_BFD_IBERTY=$(FLAGS_BFD) -liberty
-                       has_bfd_iberty := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD_IBERTY))
+                       has_bfd_iberty := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD_IBERTY),liberty)
                        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))
+                               has_bfd_iberty_z := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD_IBERTY_Z),libz)
                                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))
+                                       has_cplus_demangle := $(call try-cc,$(SOURCE_CPLUS_DEMANGLE),$(FLAGS_CPLUS_DEMANGLE),demangle)
                                        ifeq ($(has_cplus_demangle),y)
                                                EXTLIBS += -liberty
                                                BASIC_CFLAGS += -DHAVE_CPLUS_DEMANGLE
@@ -776,13 +822,19 @@ ifeq ($(NO_PERF_REGS),0)
 endif
 
 ifndef NO_STRLCPY
-       ifeq ($(call try-cc,$(SOURCE_STRLCPY),),y)
+       ifeq ($(call try-cc,$(SOURCE_STRLCPY),,-DHAVE_STRLCPY),y)
                BASIC_CFLAGS += -DHAVE_STRLCPY
        endif
 endif
 
+ifndef NO_ON_EXIT
+       ifeq ($(call try-cc,$(SOURCE_ON_EXIT),,-DHAVE_ON_EXIT),y)
+               BASIC_CFLAGS += -DHAVE_ON_EXIT
+       endif
+endif
+
 ifndef NO_BACKTRACE
-       ifeq ($(call try-cc,$(SOURCE_BACKTRACE),),y)
+       ifeq ($(call try-cc,$(SOURCE_BACKTRACE),,-DBACKTRACE_SUPPORT),y)
                BASIC_CFLAGS += -DBACKTRACE_SUPPORT
        endif
 endif
@@ -891,10 +943,14 @@ $(OUTPUT)%.s: %.S
 $(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)tests/attr.o: tests/attr.c $(OUTPUT)PERF-CFLAGS
+       $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) \
+               '-DBINDIR="$(bindir_SQ)"' \
+               $<
+
 $(OUTPUT)util/config.o: util/config.c $(OUTPUT)PERF-CFLAGS
        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 
@@ -910,6 +966,9 @@ $(OUTPUT)ui/browsers/hists.o: ui/browsers/hists.c $(OUTPUT)PERF-CFLAGS
 $(OUTPUT)ui/browsers/map.o: ui/browsers/map.c $(OUTPUT)PERF-CFLAGS
        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
+$(OUTPUT)ui/browsers/scripts.o: ui/browsers/scripts.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) -Wno-unused-parameter -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 
@@ -981,20 +1040,15 @@ help:
        @echo 'Perf maintainer targets:'
        @echo '  clean                  - clean all binary objects and build output'
 
-doc:
-       $(MAKE) -C Documentation all
-
-man:
-       $(MAKE) -C Documentation man
 
-html:
-       $(MAKE) -C Documentation html
+DOC_TARGETS := doc man html info pdf
 
-info:
-       $(MAKE) -C Documentation info
+INSTALL_DOC_TARGETS := $(patsubst %,install-%,$(DOC_TARGETS)) try-install-man
+INSTALL_DOC_TARGETS += quick-install-doc quick-install-man quick-install-html
 
-pdf:
-       $(MAKE) -C Documentation pdf
+# 'make doc' should call 'make -C Documentation all'
+$(DOC_TARGETS):
+       $(QUIET_SUBDIR0)Documentation $(QUIET_SUBDIR1) $(@:doc=all)
 
 TAGS:
        $(RM) TAGS
@@ -1045,7 +1099,7 @@ perfexec_instdir = $(prefix)/$(perfexecdir)
 endif
 perfexec_instdir_SQ = $(subst ','\'',$(perfexec_instdir))
 
-install: all
+install: all try-install-man
        $(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'
@@ -1061,33 +1115,17 @@ install: all
        $(INSTALL) scripts/python/bin/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/bin'
        $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(sysconfdir_SQ)/bash_completion.d'
        $(INSTALL) bash_completion '$(DESTDIR_SQ)$(sysconfdir_SQ)/bash_completion.d/perf'
+       $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/tests'
+       $(INSTALL) tests/attr.py '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/tests'
+       $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/tests/attr'
+       $(INSTALL) tests/attr/* '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/tests/attr'
 
 install-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
+# 'make install-doc' should call 'make -C Documentation install'
+$(INSTALL_DOC_TARGETS):
+       $(QUIET_SUBDIR0)Documentation $(QUIET_SUBDIR1) $(@:-doc=)
 
 ### Cleaning rules
 
@@ -1095,7 +1133,7 @@ clean: $(LIBTRACEEVENT)-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
+       $(QUIET_SUBDIR0)Documentation $(QUIET_SUBDIR1) clean
        $(RM) $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)PERF-CFLAGS
        $(RM) $(OUTPUT)util/*-bison*
        $(RM) $(OUTPUT)util/*-flex*
diff --git a/tools/perf/arch/common.c b/tools/perf/arch/common.c
new file mode 100644 (file)
index 0000000..3e975cb
--- /dev/null
@@ -0,0 +1,211 @@
+#include <stdio.h>
+#include <sys/utsname.h>
+#include "common.h"
+#include "../util/debug.h"
+
+const char *const arm_triplets[] = {
+       "arm-eabi-",
+       "arm-linux-androideabi-",
+       "arm-unknown-linux-",
+       "arm-unknown-linux-gnu-",
+       "arm-unknown-linux-gnueabi-",
+       NULL
+};
+
+const char *const powerpc_triplets[] = {
+       "powerpc-unknown-linux-gnu-",
+       "powerpc64-unknown-linux-gnu-",
+       NULL
+};
+
+const char *const s390_triplets[] = {
+       "s390-ibm-linux-",
+       NULL
+};
+
+const char *const sh_triplets[] = {
+       "sh-unknown-linux-gnu-",
+       "sh64-unknown-linux-gnu-",
+       NULL
+};
+
+const char *const sparc_triplets[] = {
+       "sparc-unknown-linux-gnu-",
+       "sparc64-unknown-linux-gnu-",
+       NULL
+};
+
+const char *const x86_triplets[] = {
+       "x86_64-pc-linux-gnu-",
+       "x86_64-unknown-linux-gnu-",
+       "i686-pc-linux-gnu-",
+       "i586-pc-linux-gnu-",
+       "i486-pc-linux-gnu-",
+       "i386-pc-linux-gnu-",
+       "i686-linux-android-",
+       "i686-android-linux-",
+       NULL
+};
+
+const char *const mips_triplets[] = {
+       "mips-unknown-linux-gnu-",
+       "mipsel-linux-android-",
+       NULL
+};
+
+static bool lookup_path(char *name)
+{
+       bool found = false;
+       char *path, *tmp;
+       char buf[PATH_MAX];
+       char *env = getenv("PATH");
+
+       if (!env)
+               return false;
+
+       env = strdup(env);
+       if (!env)
+               return false;
+
+       path = strtok_r(env, ":", &tmp);
+       while (path) {
+               scnprintf(buf, sizeof(buf), "%s/%s", path, name);
+               if (access(buf, F_OK) == 0) {
+                       found = true;
+                       break;
+               }
+               path = strtok_r(NULL, ":", &tmp);
+       }
+       free(env);
+       return found;
+}
+
+static int lookup_triplets(const char *const *triplets, const char *name)
+{
+       int i;
+       char buf[PATH_MAX];
+
+       for (i = 0; triplets[i] != NULL; i++) {
+               scnprintf(buf, sizeof(buf), "%s%s", triplets[i], name);
+               if (lookup_path(buf))
+                       return i;
+       }
+       return -1;
+}
+
+/*
+ * Return architecture name in a normalized form.
+ * The conversion logic comes from the Makefile.
+ */
+static const char *normalize_arch(char *arch)
+{
+       if (!strcmp(arch, "x86_64"))
+               return "x86";
+       if (arch[0] == 'i' && arch[2] == '8' && arch[3] == '6')
+               return "x86";
+       if (!strcmp(arch, "sun4u") || !strncmp(arch, "sparc", 5))
+               return "sparc";
+       if (!strncmp(arch, "arm", 3) || !strcmp(arch, "sa110"))
+               return "arm";
+       if (!strncmp(arch, "s390", 4))
+               return "s390";
+       if (!strncmp(arch, "parisc", 6))
+               return "parisc";
+       if (!strncmp(arch, "powerpc", 7) || !strncmp(arch, "ppc", 3))
+               return "powerpc";
+       if (!strncmp(arch, "mips", 4))
+               return "mips";
+       if (!strncmp(arch, "sh", 2) && isdigit(arch[2]))
+               return "sh";
+
+       return arch;
+}
+
+static int perf_session_env__lookup_binutils_path(struct perf_session_env *env,
+                                                 const char *name,
+                                                 const char **path)
+{
+       int idx;
+       const char *arch, *cross_env;
+       struct utsname uts;
+       const char *const *path_list;
+       char *buf = NULL;
+
+       arch = normalize_arch(env->arch);
+
+       if (uname(&uts) < 0)
+               goto out;
+
+       /*
+        * We don't need to try to find objdump path for native system.
+        * Just use default binutils path (e.g.: "objdump").
+        */
+       if (!strcmp(normalize_arch(uts.machine), arch))
+               goto out;
+
+       cross_env = getenv("CROSS_COMPILE");
+       if (cross_env) {
+               if (asprintf(&buf, "%s%s", cross_env, name) < 0)
+                       goto out_error;
+               if (buf[0] == '/') {
+                       if (access(buf, F_OK) == 0)
+                               goto out;
+                       goto out_error;
+               }
+               if (lookup_path(buf))
+                       goto out;
+               free(buf);
+       }
+
+       if (!strcmp(arch, "arm"))
+               path_list = arm_triplets;
+       else if (!strcmp(arch, "powerpc"))
+               path_list = powerpc_triplets;
+       else if (!strcmp(arch, "sh"))
+               path_list = sh_triplets;
+       else if (!strcmp(arch, "s390"))
+               path_list = s390_triplets;
+       else if (!strcmp(arch, "sparc"))
+               path_list = sparc_triplets;
+       else if (!strcmp(arch, "x86"))
+               path_list = x86_triplets;
+       else if (!strcmp(arch, "mips"))
+               path_list = mips_triplets;
+       else {
+               ui__error("binutils for %s not supported.\n", arch);
+               goto out_error;
+       }
+
+       idx = lookup_triplets(path_list, name);
+       if (idx < 0) {
+               ui__error("Please install %s for %s.\n"
+                         "You can add it to PATH, set CROSS_COMPILE or "
+                         "override the default using --%s.\n",
+                         name, arch, name);
+               goto out_error;
+       }
+
+       if (asprintf(&buf, "%s%s", path_list[idx], name) < 0)
+               goto out_error;
+
+out:
+       *path = buf;
+       return 0;
+out_error:
+       free(buf);
+       *path = NULL;
+       return -1;
+}
+
+int perf_session_env__lookup_objdump(struct perf_session_env *env)
+{
+       /*
+        * For live mode, env->arch will be NULL and we can use
+        * the native objdump tool.
+        */
+       if (env->arch == NULL)
+               return 0;
+
+       return perf_session_env__lookup_binutils_path(env, "objdump",
+                                                     &objdump_path);
+}
diff --git a/tools/perf/arch/common.h b/tools/perf/arch/common.h
new file mode 100644 (file)
index 0000000..ede246e
--- /dev/null
@@ -0,0 +1,10 @@
+#ifndef ARCH_PERF_COMMON_H
+#define ARCH_PERF_COMMON_H
+
+#include "../util/session.h"
+
+extern const char *objdump_path;
+
+int perf_session_env__lookup_objdump(struct perf_session_env *env);
+
+#endif /* ARCH_PERF_COMMON_H */
index 9ea3854..dc870cf 100644 (file)
 #include "util/hist.h"
 #include "util/session.h"
 #include "util/tool.h"
+#include "arch/common.h"
 
 #include <linux/bitmap.h>
 
 struct perf_annotate {
        struct perf_tool tool;
-       char const *input_name;
        bool       force, use_tui, use_stdio;
        bool       full_paths;
        bool       print_line;
@@ -139,7 +139,7 @@ find_next:
                }
 
                if (use_browser > 0) {
-                       key = hist_entry__tui_annotate(he, evidx, NULL, NULL, 0);
+                       key = hist_entry__tui_annotate(he, evidx, NULL);
                        switch (key) {
                        case K_RIGHT:
                                next = rb_next(nd);
@@ -174,7 +174,7 @@ static int __cmd_annotate(struct perf_annotate *ann)
        struct perf_evsel *pos;
        u64 total_nr_samples;
 
-       session = perf_session__new(ann->input_name, O_RDONLY,
+       session = perf_session__new(input_name, O_RDONLY,
                                    ann->force, false, &ann->tool);
        if (session == NULL)
                return -ENOMEM;
@@ -186,6 +186,12 @@ static int __cmd_annotate(struct perf_annotate *ann)
                        goto out_delete;
        }
 
+       if (!objdump_path) {
+               ret = perf_session_env__lookup_objdump(&session->header.env);
+               if (ret)
+                       goto out_delete;
+       }
+
        ret = perf_session__process_events(session, &ann->tool);
        if (ret)
                goto out_delete;
@@ -246,13 +252,14 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused)
                        .sample = process_sample_event,
                        .mmap   = perf_event__process_mmap,
                        .comm   = perf_event__process_comm,
-                       .fork   = perf_event__process_task,
+                       .exit   = perf_event__process_exit,
+                       .fork   = perf_event__process_fork,
                        .ordered_samples = true,
                        .ordering_requires_timestamps = true,
                },
        };
        const struct option options[] = {
-       OPT_STRING('i', "input", &annotate.input_name, "file",
+       OPT_STRING('i', "input", &input_name, "file",
                    "input file name"),
        OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
                   "only consider symbols in these dsos"),
index d37e077..fae8b25 100644 (file)
@@ -13,6 +13,7 @@
 #include "util/header.h"
 #include "util/parse-options.h"
 #include "util/strlist.h"
+#include "util/build-id.h"
 #include "util/symbol.h"
 
 static int build_id_cache__add_file(const char *filename, const char *debugdir)
index a0e94ff..a82d99f 100644 (file)
@@ -44,8 +44,7 @@ static int filename__fprintf_build_id(const char *name, FILE *fp)
        return fprintf(fp, "%s\n", sbuild_id);
 }
 
-static int perf_session__list_build_ids(const char *input_name,
-                                       bool force, bool with_hits)
+static int perf_session__list_build_ids(bool force, bool with_hits)
 {
        struct perf_session *session;
 
@@ -81,7 +80,6 @@ int cmd_buildid_list(int argc, const char **argv,
        bool show_kernel = false;
        bool with_hits = false;
        bool force = false;
-       const char *input_name = NULL;
        const struct option options[] = {
        OPT_BOOLEAN('H', "with-hits", &with_hits, "Show only DSOs with hits"),
        OPT_STRING('i', "input", &input_name, "file", "input file name"),
@@ -101,5 +99,5 @@ int cmd_buildid_list(int argc, const char **argv,
        if (show_kernel)
                return sysfs__fprintf_build_id(stdout);
 
-       return perf_session__list_build_ids(input_name, force, with_hits);
+       return perf_session__list_build_ids(force, with_hits);
 }
index a0b531c..93b852f 100644 (file)
@@ -24,6 +24,228 @@ static char const *input_old = "perf.data.old",
 static char      diff__default_sort_order[] = "dso,symbol";
 static bool  force;
 static bool show_displacement;
+static bool show_period;
+static bool show_formula;
+static bool show_baseline_only;
+static bool sort_compute;
+
+static s64 compute_wdiff_w1;
+static s64 compute_wdiff_w2;
+
+enum {
+       COMPUTE_DELTA,
+       COMPUTE_RATIO,
+       COMPUTE_WEIGHTED_DIFF,
+       COMPUTE_MAX,
+};
+
+const char *compute_names[COMPUTE_MAX] = {
+       [COMPUTE_DELTA] = "delta",
+       [COMPUTE_RATIO] = "ratio",
+       [COMPUTE_WEIGHTED_DIFF] = "wdiff",
+};
+
+static int compute;
+
+static int setup_compute_opt_wdiff(char *opt)
+{
+       char *w1_str = opt;
+       char *w2_str;
+
+       int ret = -EINVAL;
+
+       if (!opt)
+               goto out;
+
+       w2_str = strchr(opt, ',');
+       if (!w2_str)
+               goto out;
+
+       *w2_str++ = 0x0;
+       if (!*w2_str)
+               goto out;
+
+       compute_wdiff_w1 = strtol(w1_str, NULL, 10);
+       compute_wdiff_w2 = strtol(w2_str, NULL, 10);
+
+       if (!compute_wdiff_w1 || !compute_wdiff_w2)
+               goto out;
+
+       pr_debug("compute wdiff w1(%" PRId64 ") w2(%" PRId64 ")\n",
+                 compute_wdiff_w1, compute_wdiff_w2);
+
+       ret = 0;
+
+ out:
+       if (ret)
+               pr_err("Failed: wrong weight data, use 'wdiff:w1,w2'\n");
+
+       return ret;
+}
+
+static int setup_compute_opt(char *opt)
+{
+       if (compute == COMPUTE_WEIGHTED_DIFF)
+               return setup_compute_opt_wdiff(opt);
+
+       if (opt) {
+               pr_err("Failed: extra option specified '%s'", opt);
+               return -EINVAL;
+       }
+
+       return 0;
+}
+
+static int setup_compute(const struct option *opt, const char *str,
+                        int unset __maybe_unused)
+{
+       int *cp = (int *) opt->value;
+       char *cstr = (char *) str;
+       char buf[50];
+       unsigned i;
+       char *option;
+
+       if (!str) {
+               *cp = COMPUTE_DELTA;
+               return 0;
+       }
+
+       if (*str == '+') {
+               sort_compute = true;
+               cstr = (char *) ++str;
+               if (!*str)
+                       return 0;
+       }
+
+       option = strchr(str, ':');
+       if (option) {
+               unsigned len = option++ - str;
+
+               /*
+                * The str data are not writeable, so we need
+                * to use another buffer.
+                */
+
+               /* No option value is longer. */
+               if (len >= sizeof(buf))
+                       return -EINVAL;
+
+               strncpy(buf, str, len);
+               buf[len] = 0x0;
+               cstr = buf;
+       }
+
+       for (i = 0; i < COMPUTE_MAX; i++)
+               if (!strcmp(cstr, compute_names[i])) {
+                       *cp = i;
+                       return setup_compute_opt(option);
+               }
+
+       pr_err("Failed: '%s' is not computation method "
+              "(use 'delta','ratio' or 'wdiff')\n", str);
+       return -EINVAL;
+}
+
+static double get_period_percent(struct hist_entry *he, u64 period)
+{
+       u64 total = he->hists->stats.total_period;
+       return (period * 100.0) / total;
+}
+
+double perf_diff__compute_delta(struct hist_entry *he)
+{
+       struct hist_entry *pair = hist_entry__next_pair(he);
+       double new_percent = get_period_percent(he, he->stat.period);
+       double old_percent = pair ? get_period_percent(pair, pair->stat.period) : 0.0;
+
+       he->diff.period_ratio_delta = new_percent - old_percent;
+       he->diff.computed = true;
+       return he->diff.period_ratio_delta;
+}
+
+double perf_diff__compute_ratio(struct hist_entry *he)
+{
+       struct hist_entry *pair = hist_entry__next_pair(he);
+       double new_period = he->stat.period;
+       double old_period = pair ? pair->stat.period : 0;
+
+       he->diff.computed = true;
+       he->diff.period_ratio = pair ? (new_period / old_period) : 0;
+       return he->diff.period_ratio;
+}
+
+s64 perf_diff__compute_wdiff(struct hist_entry *he)
+{
+       struct hist_entry *pair = hist_entry__next_pair(he);
+       u64 new_period = he->stat.period;
+       u64 old_period = pair ? pair->stat.period : 0;
+
+       he->diff.computed = true;
+
+       if (!pair)
+               he->diff.wdiff = 0;
+       else
+               he->diff.wdiff = new_period * compute_wdiff_w2 -
+                                old_period * compute_wdiff_w1;
+
+       return he->diff.wdiff;
+}
+
+static int formula_delta(struct hist_entry *he, char *buf, size_t size)
+{
+       struct hist_entry *pair = hist_entry__next_pair(he);
+
+       if (!pair)
+               return -1;
+
+       return scnprintf(buf, size,
+                        "(%" PRIu64 " * 100 / %" PRIu64 ") - "
+                        "(%" PRIu64 " * 100 / %" PRIu64 ")",
+                         he->stat.period, he->hists->stats.total_period,
+                         pair->stat.period, pair->hists->stats.total_period);
+}
+
+static int formula_ratio(struct hist_entry *he, char *buf, size_t size)
+{
+       struct hist_entry *pair = hist_entry__next_pair(he);
+       double new_period = he->stat.period;
+       double old_period = pair ? pair->stat.period : 0;
+
+       if (!pair)
+               return -1;
+
+       return scnprintf(buf, size, "%.0F / %.0F", new_period, old_period);
+}
+
+static int formula_wdiff(struct hist_entry *he, char *buf, size_t size)
+{
+       struct hist_entry *pair = hist_entry__next_pair(he);
+       u64 new_period = he->stat.period;
+       u64 old_period = pair ? pair->stat.period : 0;
+
+       if (!pair)
+               return -1;
+
+       return scnprintf(buf, size,
+                 "(%" PRIu64 " * " "%" PRId64 ") - (%" PRIu64 " * " "%" PRId64 ")",
+                 new_period, compute_wdiff_w2, old_period, compute_wdiff_w1);
+}
+
+int perf_diff__formula(char *buf, size_t size, struct hist_entry *he)
+{
+       switch (compute) {
+       case COMPUTE_DELTA:
+               return formula_delta(he, buf, size);
+       case COMPUTE_RATIO:
+               return formula_ratio(he, buf, size);
+       case COMPUTE_WEIGHTED_DIFF:
+               return formula_wdiff(he, buf, size);
+       default:
+               BUG_ON(1);
+       }
+
+       return -1;
+}
 
 static int hists__add_entry(struct hists *self,
                            struct addr_location *al, u64 period)
@@ -47,7 +269,7 @@ static int diff__process_sample_event(struct perf_tool *tool __maybe_unused,
                return -1;
        }
 
-       if (al.filtered || al.sym == NULL)
+       if (al.filtered)
                return 0;
 
        if (hists__add_entry(&evsel->hists, &al, sample->period)) {
@@ -63,8 +285,8 @@ static struct perf_tool tool = {
        .sample = diff__process_sample_event,
        .mmap   = perf_event__process_mmap,
        .comm   = perf_event__process_comm,
-       .exit   = perf_event__process_task,
-       .fork   = perf_event__process_task,
+       .exit   = perf_event__process_exit,
+       .fork   = perf_event__process_fork,
        .lost   = perf_event__process_lost,
        .ordered_samples = true,
        .ordering_requires_timestamps = true,
@@ -112,36 +334,6 @@ static void hists__name_resort(struct hists *self, bool sort)
                self->entries = tmp;
 }
 
-static struct hist_entry *hists__find_entry(struct hists *self,
-                                           struct hist_entry *he)
-{
-       struct rb_node *n = self->entries.rb_node;
-
-       while (n) {
-               struct hist_entry *iter = rb_entry(n, struct hist_entry, rb_node);
-               int64_t cmp = hist_entry__cmp(he, iter);
-
-               if (cmp < 0)
-                       n = n->rb_left;
-               else if (cmp > 0)
-                       n = n->rb_right;
-               else
-                       return iter;
-       }
-
-       return NULL;
-}
-
-static void hists__match(struct hists *older, struct hists *newer)
-{
-       struct rb_node *nd;
-
-       for (nd = rb_first(&newer->entries); nd; nd = rb_next(nd)) {
-               struct hist_entry *pos = rb_entry(nd, struct hist_entry, rb_node);
-               pos->pair = hists__find_entry(older, pos);
-       }
-}
-
 static struct perf_evsel *evsel_match(struct perf_evsel *evsel,
                                      struct perf_evlist *evlist)
 {
@@ -172,6 +364,144 @@ static void perf_evlist__resort_hists(struct perf_evlist *evlist, bool name)
        }
 }
 
+static void hists__baseline_only(struct hists *hists)
+{
+       struct rb_node *next = rb_first(&hists->entries);
+
+       while (next != NULL) {
+               struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node);
+
+               next = rb_next(&he->rb_node);
+               if (!hist_entry__next_pair(he)) {
+                       rb_erase(&he->rb_node, &hists->entries);
+                       hist_entry__free(he);
+               }
+       }
+}
+
+static void hists__precompute(struct hists *hists)
+{
+       struct rb_node *next = rb_first(&hists->entries);
+
+       while (next != NULL) {
+               struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node);
+
+               next = rb_next(&he->rb_node);
+
+               switch (compute) {
+               case COMPUTE_DELTA:
+                       perf_diff__compute_delta(he);
+                       break;
+               case COMPUTE_RATIO:
+                       perf_diff__compute_ratio(he);
+                       break;
+               case COMPUTE_WEIGHTED_DIFF:
+                       perf_diff__compute_wdiff(he);
+                       break;
+               default:
+                       BUG_ON(1);
+               }
+       }
+}
+
+static int64_t cmp_doubles(double l, double r)
+{
+       if (l > r)
+               return -1;
+       else if (l < r)
+               return 1;
+       else
+               return 0;
+}
+
+static int64_t
+hist_entry__cmp_compute(struct hist_entry *left, struct hist_entry *right,
+                       int c)
+{
+       switch (c) {
+       case COMPUTE_DELTA:
+       {
+               double l = left->diff.period_ratio_delta;
+               double r = right->diff.period_ratio_delta;
+
+               return cmp_doubles(l, r);
+       }
+       case COMPUTE_RATIO:
+       {
+               double l = left->diff.period_ratio;
+               double r = right->diff.period_ratio;
+
+               return cmp_doubles(l, r);
+       }
+       case COMPUTE_WEIGHTED_DIFF:
+       {
+               s64 l = left->diff.wdiff;
+               s64 r = right->diff.wdiff;
+
+               return r - l;
+       }
+       default:
+               BUG_ON(1);
+       }
+
+       return 0;
+}
+
+static void insert_hist_entry_by_compute(struct rb_root *root,
+                                        struct hist_entry *he,
+                                        int c)
+{
+       struct rb_node **p = &root->rb_node;
+       struct rb_node *parent = NULL;
+       struct hist_entry *iter;
+
+       while (*p != NULL) {
+               parent = *p;
+               iter = rb_entry(parent, struct hist_entry, rb_node);
+               if (hist_entry__cmp_compute(he, iter, c) < 0)
+                       p = &(*p)->rb_left;
+               else
+                       p = &(*p)->rb_right;
+       }
+
+       rb_link_node(&he->rb_node, parent, p);
+       rb_insert_color(&he->rb_node, root);
+}
+
+static void hists__compute_resort(struct hists *hists)
+{
+       struct rb_root tmp = RB_ROOT;
+       struct rb_node *next = rb_first(&hists->entries);
+
+       while (next != NULL) {
+               struct hist_entry *he = rb_entry(next, struct hist_entry, rb_node);
+
+               next = rb_next(&he->rb_node);
+
+               rb_erase(&he->rb_node, &hists->entries);
+               insert_hist_entry_by_compute(&tmp, he, compute);
+       }
+
+       hists->entries = tmp;
+}
+
+static void hists__process(struct hists *old, struct hists *new)
+{
+       hists__match(new, old);
+
+       if (show_baseline_only)
+               hists__baseline_only(new);
+       else
+               hists__link(new, old);
+
+       if (sort_compute) {
+               hists__precompute(new);
+               hists__compute_resort(new);
+       }
+
+       hists__fprintf(new, true, 0, 0, stdout);
+}
+
 static int __cmd_diff(void)
 {
        int ret, i;
@@ -213,8 +543,7 @@ static int __cmd_diff(void)
 
                first = false;
 
-               hists__match(&evsel_old->hists, &evsel->hists);
-               hists__fprintf(&evsel->hists, true, 0, 0, stdout);
+               hists__process(&evsel_old->hists, &evsel->hists);
        }
 
 out_delete:
@@ -235,6 +564,16 @@ static const struct option options[] = {
                    "be more verbose (show symbol address, etc)"),
        OPT_BOOLEAN('M', "displacement", &show_displacement,
                    "Show position displacement relative to baseline"),
+       OPT_BOOLEAN('b', "baseline-only", &show_baseline_only,
+                   "Show only items with match in baseline"),
+       OPT_CALLBACK('c', "compute", &compute,
+                    "delta,ratio,wdiff:w1,w2 (default delta)",
+                    "Entries differential computation selection",
+                    setup_compute),
+       OPT_BOOLEAN('p', "period", &show_period,
+                   "Show period values."),
+       OPT_BOOLEAN('F', "formula", &show_formula,
+                   "Show formula."),
        OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
                    "dump raw trace in ASCII"),
        OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
@@ -263,12 +602,36 @@ static void ui_init(void)
        /* No overhead column. */
        perf_hpp__column_enable(PERF_HPP__OVERHEAD, false);
 
-       /* Display baseline/delta/displacement columns. */
+       /*
+        * Display baseline/delta/ratio/displacement/
+        * formula/periods columns.
+        */
        perf_hpp__column_enable(PERF_HPP__BASELINE, true);
-       perf_hpp__column_enable(PERF_HPP__DELTA, true);
+
+       switch (compute) {
+       case COMPUTE_DELTA:
+               perf_hpp__column_enable(PERF_HPP__DELTA, true);
+               break;
+       case COMPUTE_RATIO:
+               perf_hpp__column_enable(PERF_HPP__RATIO, true);
+               break;
+       case COMPUTE_WEIGHTED_DIFF:
+               perf_hpp__column_enable(PERF_HPP__WEIGHTED_DIFF, true);
+               break;
+       default:
+               BUG_ON(1);
+       };
 
        if (show_displacement)
                perf_hpp__column_enable(PERF_HPP__DISPL, true);
+
+       if (show_formula)
+               perf_hpp__column_enable(PERF_HPP__FORMULA, true);
+
+       if (show_period) {
+               perf_hpp__column_enable(PERF_HPP__PERIOD, true);
+               perf_hpp__column_enable(PERF_HPP__PERIOD_BASELINE, true);
+       }
 }
 
 int cmd_diff(int argc, const char **argv, const char *prefix __maybe_unused)
index 997afb8..c20f1dc 100644 (file)
@@ -48,12 +48,12 @@ static int __if_print(bool *first, const char *field, u64 value)
 
 #define if_print(field) __if_print(&first, #field, pos->attr.field)
 
-static int __cmd_evlist(const char *input_name, struct perf_attr_details *details)
+static int __cmd_evlist(const char *file_name, struct perf_attr_details *details)
 {
        struct perf_session *session;
        struct perf_evsel *pos;
 
-       session = perf_session__new(input_name, O_RDONLY, 0, false, NULL);
+       session = perf_session__new(file_name, O_RDONLY, 0, false, NULL);
        if (session == NULL)
                return -ENOMEM;
 
@@ -111,7 +111,6 @@ static int __cmd_evlist(const char *input_name, struct perf_attr_details *detail
 int cmd_evlist(int argc, const char **argv, const char *prefix __maybe_unused)
 {
        struct perf_attr_details details = { .verbose = false, };
-       const char *input_name = NULL;
        const struct option options[] = {
        OPT_STRING('i', "input", &input_name, "file", "Input file name"),
        OPT_BOOLEAN('F', "freq", &details.freq, "Show the sample frequency"),
index 4688bea..84ad6ab 100644 (file)
@@ -8,33 +8,53 @@
 #include "builtin.h"
 
 #include "perf.h"
+#include "util/color.h"
+#include "util/evlist.h"
+#include "util/evsel.h"
 #include "util/session.h"
 #include "util/tool.h"
 #include "util/debug.h"
+#include "util/build-id.h"
 
 #include "util/parse-options.h"
 
+#include <linux/list.h>
+
 struct perf_inject {
        struct perf_tool tool;
        bool             build_ids;
+       bool             sched_stat;
+       const char       *input_name;
+       int              pipe_output,
+                        output;
+       u64              bytes_written;
+       struct list_head samples;
+};
+
+struct event_entry {
+       struct list_head node;
+       u32              tid;
+       union perf_event event[0];
 };
 
-static int perf_event__repipe_synth(struct perf_tool *tool __maybe_unused,
+static int perf_event__repipe_synth(struct perf_tool *tool,
                                    union perf_event *event,
                                    struct machine *machine __maybe_unused)
 {
+       struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
        uint32_t size;
        void *buf = event;
 
        size = event->header.size;
 
        while (size) {
-               int ret = write(STDOUT_FILENO, buf, size);
+               int ret = write(inject->output, buf, size);
                if (ret < 0)
                        return -errno;
 
                size -= ret;
                buf += ret;
+               inject->bytes_written += ret;
        }
 
        return 0;
@@ -80,12 +100,25 @@ static int perf_event__repipe(struct perf_tool *tool,
        return perf_event__repipe_synth(tool, event, machine);
 }
 
+typedef int (*inject_handler)(struct perf_tool *tool,
+                             union perf_event *event,
+                             struct perf_sample *sample,
+                             struct perf_evsel *evsel,
+                             struct machine *machine);
+
 static int perf_event__repipe_sample(struct perf_tool *tool,
                                     union perf_event *event,
-                             struct perf_sample *sample __maybe_unused,
-                             struct perf_evsel *evsel __maybe_unused,
-                             struct machine *machine)
+                                    struct perf_sample *sample,
+                                    struct perf_evsel *evsel,
+                                    struct machine *machine)
 {
+       if (evsel->handler.func) {
+               inject_handler f = evsel->handler.func;
+               return f(tool, event, sample, evsel, machine);
+       }
+
+       build_id__mark_dso_hit(tool, event, sample, evsel, machine);
+
        return perf_event__repipe_synth(tool, event, machine);
 }
 
@@ -102,14 +135,14 @@ static int perf_event__repipe_mmap(struct perf_tool *tool,
        return err;
 }
 
-static int perf_event__repipe_task(struct perf_tool *tool,
+static int perf_event__repipe_fork(struct perf_tool *tool,
                                   union perf_event *event,
                                   struct perf_sample *sample,
                                   struct machine *machine)
 {
        int err;
 
-       err = perf_event__process_task(tool, event, sample, machine);
+       err = perf_event__process_fork(tool, event, sample, machine);
        perf_event__repipe(tool, event, sample, machine);
 
        return err;
@@ -210,6 +243,80 @@ repipe:
        return 0;
 }
 
+static int perf_inject__sched_process_exit(struct perf_tool *tool,
+                                          union perf_event *event __maybe_unused,
+                                          struct perf_sample *sample,
+                                          struct perf_evsel *evsel __maybe_unused,
+                                          struct machine *machine __maybe_unused)
+{
+       struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
+       struct event_entry *ent;
+
+       list_for_each_entry(ent, &inject->samples, node) {
+               if (sample->tid == ent->tid) {
+                       list_del_init(&ent->node);
+                       free(ent);
+                       break;
+               }
+       }
+
+       return 0;
+}
+
+static int perf_inject__sched_switch(struct perf_tool *tool,
+                                    union perf_event *event,
+                                    struct perf_sample *sample,
+                                    struct perf_evsel *evsel,
+                                    struct machine *machine)
+{
+       struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
+       struct event_entry *ent;
+
+       perf_inject__sched_process_exit(tool, event, sample, evsel, machine);
+
+       ent = malloc(event->header.size + sizeof(struct event_entry));
+       if (ent == NULL) {
+               color_fprintf(stderr, PERF_COLOR_RED,
+                            "Not enough memory to process sched switch event!");
+               return -1;
+       }
+
+       ent->tid = sample->tid;
+       memcpy(&ent->event, event, event->header.size);
+       list_add(&ent->node, &inject->samples);
+       return 0;
+}
+
+static int perf_inject__sched_stat(struct perf_tool *tool,
+                                  union perf_event *event __maybe_unused,
+                                  struct perf_sample *sample,
+                                  struct perf_evsel *evsel,
+                                  struct machine *machine)
+{
+       struct event_entry *ent;
+       union perf_event *event_sw;
+       struct perf_sample sample_sw;
+       struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
+       u32 pid = perf_evsel__intval(evsel, sample, "pid");
+
+       list_for_each_entry(ent, &inject->samples, node) {
+               if (pid == ent->tid)
+                       goto found;
+       }
+
+       return 0;
+found:
+       event_sw = &ent->event[0];
+       perf_evsel__parse_sample(evsel, event_sw, &sample_sw);
+
+       sample_sw.period = sample->period;
+       sample_sw.time   = sample->time;
+       perf_event__synthesize_sample(event_sw, evsel->attr.sample_type,
+                                     &sample_sw, false);
+       build_id__mark_dso_hit(tool, event_sw, &sample_sw, evsel, machine);
+       return perf_event__repipe(tool, event_sw, &sample_sw, machine);
+}
+
 extern volatile int session_done;
 
 static void sig_handler(int sig __maybe_unused)
@@ -217,6 +324,21 @@ static void sig_handler(int sig __maybe_unused)
        session_done = 1;
 }
 
+static int perf_evsel__check_stype(struct perf_evsel *evsel,
+                                  u64 sample_type, const char *sample_msg)
+{
+       struct perf_event_attr *attr = &evsel->attr;
+       const char *name = perf_evsel__name(evsel);
+
+       if (!(attr->sample_type & sample_type)) {
+               pr_err("Samples for %s event do not have %s attribute set.",
+                       name, sample_msg);
+               return -EINVAL;
+       }
+
+       return 0;
+}
+
 static int __cmd_inject(struct perf_inject *inject)
 {
        struct perf_session *session;
@@ -224,19 +346,48 @@ static int __cmd_inject(struct perf_inject *inject)
 
        signal(SIGINT, sig_handler);
 
-       if (inject->build_ids) {
-               inject->tool.sample       = perf_event__inject_buildid;
+       if (inject->build_ids || inject->sched_stat) {
                inject->tool.mmap         = perf_event__repipe_mmap;
-               inject->tool.fork         = perf_event__repipe_task;
+               inject->tool.fork         = perf_event__repipe_fork;
                inject->tool.tracing_data = perf_event__repipe_tracing_data;
        }
 
-       session = perf_session__new("-", O_RDONLY, false, true, &inject->tool);
+       session = perf_session__new(inject->input_name, O_RDONLY, false, true, &inject->tool);
        if (session == NULL)
                return -ENOMEM;
 
+       if (inject->build_ids) {
+               inject->tool.sample = perf_event__inject_buildid;
+       } else if (inject->sched_stat) {
+               struct perf_evsel *evsel;
+
+               inject->tool.ordered_samples = true;
+
+               list_for_each_entry(evsel, &session->evlist->entries, node) {
+                       const char *name = perf_evsel__name(evsel);
+
+                       if (!strcmp(name, "sched:sched_switch")) {
+                               if (perf_evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID"))
+                                       return -EINVAL;
+
+                               evsel->handler.func = perf_inject__sched_switch;
+                       } else if (!strcmp(name, "sched:sched_process_exit"))
+                               evsel->handler.func = perf_inject__sched_process_exit;
+                       else if (!strncmp(name, "sched:sched_stat_", 17))
+                               evsel->handler.func = perf_inject__sched_stat;
+               }
+       }
+
+       if (!inject->pipe_output)
+               lseek(inject->output, session->header.data_offset, SEEK_SET);
+
        ret = perf_session__process_events(session, &inject->tool);
 
+       if (!inject->pipe_output) {
+               session->header.data_size = inject->bytes_written;
+               perf_session__write_header(session, session->evlist, inject->output, true);
+       }
+
        perf_session__delete(session);
 
        return ret;
@@ -260,10 +411,20 @@ int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
                        .tracing_data   = perf_event__repipe_tracing_data_synth,
                        .build_id       = perf_event__repipe_op2_synth,
                },
+               .input_name  = "-",
+               .samples = LIST_HEAD_INIT(inject.samples),
        };
+       const char *output_name = "-";
        const struct option options[] = {
                OPT_BOOLEAN('b', "build-ids", &inject.build_ids,
                            "Inject build-ids into the output stream"),
+               OPT_STRING('i', "input", &inject.input_name, "file",
+                          "input file name"),
+               OPT_STRING('o', "output", &output_name, "file",
+                          "output file name"),
+               OPT_BOOLEAN('s', "sched-stat", &inject.sched_stat,
+                           "Merge sched-stat and sched-switch for getting events "
+                           "where and how long tasks slept"),
                OPT_INCR('v', "verbose", &verbose,
                         "be more verbose (show build ids, etc)"),
                OPT_END()
@@ -281,6 +442,18 @@ int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
        if (argc)
                usage_with_options(inject_usage, options);
 
+       if (!strcmp(output_name, "-")) {
+               inject.pipe_output = 1;
+               inject.output = STDOUT_FILENO;
+       } else {
+               inject.output = open(output_name, O_CREAT | O_WRONLY | O_TRUNC,
+                                                 S_IRUSR | S_IWUSR);
+               if (inject.output < 0) {
+                       perror("failed to create output file");
+                       return -1;
+               }
+       }
+
        if (symbol__init() < 0)
                return -1;
 
index 14bf82f..0b4b796 100644 (file)
@@ -477,7 +477,7 @@ static void sort_result(void)
        __sort_result(&root_caller_stat, &root_caller_sorted, &caller_sort);
 }
 
-static int __cmd_kmem(const char *input_name)
+static int __cmd_kmem(void)
 {
        int err = -EINVAL;
        struct perf_session *session;
@@ -743,7 +743,6 @@ static int __cmd_record(int argc, const char **argv)
 int cmd_kmem(int argc, const char **argv, const char *prefix __maybe_unused)
 {
        const char * const default_sort_order = "frag,hit,bytes";
-       const char *input_name = NULL;
        const struct option kmem_options[] = {
        OPT_STRING('i', "input", &input_name, "file", "input file name"),
        OPT_CALLBACK_NOOPT(0, "caller", NULL, NULL,
@@ -779,7 +778,7 @@ int cmd_kmem(int argc, const char **argv, const char *prefix __maybe_unused)
                if (list_empty(&alloc_sort))
                        setup_sorting(&alloc_sort, default_sort_order);
 
-               return __cmd_kmem(input_name);
+               return __cmd_kmem();
        } else
                usage_with_options(kmem_usage, kmem_options);
 
index 283b439..ca3f80e 100644 (file)
@@ -314,9 +314,9 @@ struct vcpu_event_record {
 
 static void init_kvm_event_record(struct perf_kvm_stat *kvm)
 {
-       int i;
+       unsigned int i;
 
-       for (i = 0; i < (int)EVENTS_CACHE_SIZE; i++)
+       for (i = 0; i < EVENTS_CACHE_SIZE; i++)
                INIT_LIST_HEAD(&kvm->kvm_events_cache[i]);
 }
 
@@ -370,9 +370,10 @@ static struct kvm_event *find_create_kvm_event(struct perf_kvm_stat *kvm,
        BUG_ON(key->key == INVALID_KEY);
 
        head = &kvm->kvm_events_cache[kvm_events_hash_fn(key->key)];
-       list_for_each_entry(event, head, hash_entry)
+       list_for_each_entry(event, head, hash_entry) {
                if (event->key.key == key->key && event->key.info == key->info)
                        return event;
+       }
 
        event = kvm_alloc_init_event(key);
        if (!event)
@@ -417,7 +418,10 @@ static double kvm_event_rel_stddev(int vcpu_id, struct kvm_event *event)
 static bool update_kvm_event(struct kvm_event *event, int vcpu_id,
                             u64 time_diff)
 {
-       kvm_update_event_stats(&event->total, time_diff);
+       if (vcpu_id == -1) {
+               kvm_update_event_stats(&event->total, time_diff);
+               return true;
+       }
 
        if (!kvm_event_expand(event, vcpu_id))
                return false;
@@ -433,6 +437,12 @@ static bool handle_end_event(struct perf_kvm_stat *kvm,
 {
        struct kvm_event *event;
        u64 time_begin, time_diff;
+       int vcpu;
+
+       if (kvm->trace_vcpu == -1)
+               vcpu = -1;
+       else
+               vcpu = vcpu_record->vcpu_id;
 
        event = vcpu_record->last_event;
        time_begin = vcpu_record->start_time;
@@ -462,7 +472,7 @@ static bool handle_end_event(struct perf_kvm_stat *kvm,
        BUG_ON(timestamp < time_begin);
 
        time_diff = timestamp - time_begin;
-       return update_kvm_event(event, vcpu_record->vcpu_id, time_diff);
+       return update_kvm_event(event, vcpu, time_diff);
 }
 
 static
@@ -499,6 +509,11 @@ static bool handle_kvm_event(struct perf_kvm_stat *kvm,
        if (!vcpu_record)
                return true;
 
+       /* only process events for vcpus user cares about */
+       if ((kvm->trace_vcpu != -1) &&
+           (kvm->trace_vcpu != vcpu_record->vcpu_id))
+               return true;
+
        if (kvm->events_ops->is_begin_event(evsel, sample, &key))
                return handle_begin_event(kvm, vcpu_record, &key, sample->time);
 
@@ -598,13 +613,15 @@ static void sort_result(struct perf_kvm_stat *kvm)
        int vcpu = kvm->trace_vcpu;
        struct kvm_event *event;
 
-       for (i = 0; i < EVENTS_CACHE_SIZE; i++)
-               list_for_each_entry(event, &kvm->kvm_events_cache[i], hash_entry)
+       for (i = 0; i < EVENTS_CACHE_SIZE; i++) {
+               list_for_each_entry(event, &kvm->kvm_events_cache[i], hash_entry) {
                        if (event_is_valid(event, vcpu)) {
                                update_total_count(kvm, event);
                                insert_to_result(&kvm->result, event,
                                                 kvm->compare, vcpu);
                        }
+               }
+       }
 }
 
 /* returns left most element of result, and erase it */
@@ -661,8 +678,8 @@ static void print_result(struct perf_kvm_stat *kvm)
                pr_info("\n");
        }
 
-       pr_info("\nTotal Samples:%lld, Total events handled time:%.2fus.\n\n",
-               (unsigned long long)kvm->total_count, kvm->total_time / 1e3);
+       pr_info("\nTotal Samples:%" PRIu64 ", Total events handled time:%.2fus.\n\n",
+               kvm->total_count, kvm->total_time / 1e3);
 }
 
 static int process_sample_event(struct perf_tool *tool,
index 6f5f328..4258300 100644 (file)
@@ -335,8 +335,6 @@ alloc_failed:
        return NULL;
 }
 
-static const char *input_name;
-
 struct trace_lock_handler {
        int (*acquire_event)(struct perf_evsel *evsel,
                             struct perf_sample *sample);
index e923165..f3151d3 100644 (file)
 #include <sched.h>
 #include <sys/mman.h>
 
+#ifndef HAVE_ON_EXIT
+#ifndef ATEXIT_MAX
+#define ATEXIT_MAX 32
+#endif
+static int __on_exit_count = 0;
+typedef void (*on_exit_func_t) (int, void *);
+static on_exit_func_t __on_exit_funcs[ATEXIT_MAX];
+static void *__on_exit_args[ATEXIT_MAX];
+static int __exitcode = 0;
+static void __handle_on_exit_funcs(void);
+static int on_exit(on_exit_func_t function, void *arg);
+#define exit(x) (exit)(__exitcode = (x))
+
+static int on_exit(on_exit_func_t function, void *arg)
+{
+       if (__on_exit_count == ATEXIT_MAX)
+               return -ENOMEM;
+       else if (__on_exit_count == 0)
+               atexit(__handle_on_exit_funcs);
+       __on_exit_funcs[__on_exit_count] = function;
+       __on_exit_args[__on_exit_count++] = arg;
+       return 0;
+}
+
+static void __handle_on_exit_funcs(void)
+{
+       int i;
+       for (i = 0; i < __on_exit_count; i++)
+               __on_exit_funcs[i] (__exitcode, __on_exit_args[i]);
+}
+#endif
+
 enum write_mode_t {
        WRITE_FORCE,
        WRITE_APPEND
@@ -198,11 +230,15 @@ static int perf_record__open(struct perf_record *rec)
        struct perf_record_opts *opts = &rec->opts;
        int rc = 0;
 
-       perf_evlist__config_attrs(evlist, opts);
-
+       /*
+        * Set the evsel leader links before we configure attributes,
+        * since some might depend on this info.
+        */
        if (opts->group)
                perf_evlist__set_leader(evlist);
 
+       perf_evlist__config_attrs(evlist, opts);
+
        list_for_each_entry(pos, &evlist->entries, node) {
                struct perf_event_attr *attr = &pos->attr;
                /*
@@ -285,6 +321,11 @@ try_again:
                                          perf_evsel__name(pos));
                                rc = -err;
                                goto out;
+                       } else if ((err == EOPNOTSUPP) && (attr->precise_ip)) {
+                               ui__error("\'precise\' request may not be supported. "
+                                         "Try removing 'p' modifier\n");
+                               rc = -err;
+                               goto out;
                        }
 
                        printf("\n");
@@ -326,7 +367,8 @@ try_again:
                               "or try again with a smaller value of -m/--mmap_pages.\n"
                               "(current value: %d)\n", opts->mmap_pages);
                        rc = -errno;
-               } else if (!is_power_of_2(opts->mmap_pages)) {
+               } else if (!is_power_of_2(opts->mmap_pages) &&
+                          (opts->mmap_pages != UINT_MAX)) {
                        pr_err("--mmap_pages/-m value must be a power of two.");
                        rc = -EINVAL;
                } else {
@@ -460,6 +502,7 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
        struct perf_evlist *evsel_list = rec->evlist;
        const char *output_name = rec->output_name;
        struct perf_session *session;
+       bool disabled = false;
 
        rec->progname = argv[0];
 
@@ -659,7 +702,13 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
                }
        }
 
-       perf_evlist__enable(evsel_list);
+       /*
+        * When perf is starting the traced process, all the events
+        * (apart from group members) have enable_on_exec=1 set,
+        * so don't spoil it by prematurely enabling them.
+        */
+       if (!perf_target__none(&opts->target))
+               perf_evlist__enable(evsel_list);
 
        /*
         * Let the child rip
@@ -682,8 +731,15 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
                        waking++;
                }
 
-               if (done)
+               /*
+                * When perf is starting the traced process, at the end events
+                * die with the process and we wait for that. Thus no need to
+                * disable events in this case.
+                */
+               if (done && !disabled && !perf_target__none(&opts->target)) {
                        perf_evlist__disable(evsel_list);
+                       disabled = true;
+               }
        }
 
        if (quiet || signr == SIGUSR1)
index a61725d..fc25100 100644 (file)
 #include "util/thread.h"
 #include "util/sort.h"
 #include "util/hist.h"
+#include "arch/common.h"
 
 #include <linux/bitmap.h>
 
 struct perf_report {
        struct perf_tool        tool;
        struct perf_session     *session;
-       char const              *input_name;
        bool                    force, use_tui, use_gtk, use_stdio;
        bool                    hide_unresolved;
        bool                    dont_use_callchains;
@@ -428,10 +428,11 @@ static int __cmd_report(struct perf_report *rep)
        if (use_browser > 0) {
                if (use_browser == 1) {
                        perf_evlist__tui_browse_hists(session->evlist, help,
-                                                     NULL, NULL, 0);
+                                                     NULL,
+                                                     &session->header.env);
                } else if (use_browser == 2) {
                        perf_evlist__gtk_browse_hists(session->evlist, help,
-                                                     NULL, NULL, 0);
+                                                     NULL);
                }
        } else
                perf_evlist__tty_browse_hists(session->evlist, rep, help);
@@ -556,8 +557,8 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                        .sample          = process_sample_event,
                        .mmap            = perf_event__process_mmap,
                        .comm            = perf_event__process_comm,
-                       .exit            = perf_event__process_task,
-                       .fork            = perf_event__process_task,
+                       .exit            = perf_event__process_exit,
+                       .fork            = perf_event__process_fork,
                        .lost            = perf_event__process_lost,
                        .read            = process_read_event,
                        .attr            = perf_event__process_attr,
@@ -570,7 +571,7 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                .pretty_printing_style   = "normal",
        };
        const struct option options[] = {
-       OPT_STRING('i', "input", &report.input_name, "file",
+       OPT_STRING('i', "input", &input_name, "file",
                    "input file name"),
        OPT_INCR('v', "verbose", &verbose,
                    "be more verbose (show symbol address, etc)"),
@@ -656,13 +657,13 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
        if (report.inverted_callchain)
                callchain_param.order = ORDER_CALLER;
 
-       if (!report.input_name || !strlen(report.input_name)) {
+       if (!input_name || !strlen(input_name)) {
                if (!fstat(STDIN_FILENO, &st) && S_ISFIFO(st.st_mode))
-                       report.input_name = "-";
+                       input_name = "-";
                else
-                       report.input_name = "perf.data";
+                       input_name = "perf.data";
        }
-       session = perf_session__new(report.input_name, O_RDONLY,
+       session = perf_session__new(input_name, O_RDONLY,
                                    report.force, false, &report.tool);
        if (session == NULL)
                return -ENOMEM;
@@ -687,7 +688,7 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
 
        }
 
-       if (strcmp(report.input_name, "-") != 0)
+       if (strcmp(input_name, "-") != 0)
                setup_browser(true);
        else {
                use_browser = 0;
index 3488ead..cc28b85 100644 (file)
@@ -120,7 +120,6 @@ struct trace_sched_handler {
 
 struct perf_sched {
        struct perf_tool tool;
-       const char       *input_name;
        const char       *sort_order;
        unsigned long    nr_tasks;
        struct task_desc *pid_to_task[MAX_PID];
@@ -1460,7 +1459,7 @@ static int perf_sched__read_events(struct perf_sched *sched, bool destroy,
        };
        struct perf_session *session;
 
-       session = perf_session__new(sched->input_name, O_RDONLY, 0, false, &sched->tool);
+       session = perf_session__new(input_name, O_RDONLY, 0, false, &sched->tool);
        if (session == NULL) {
                pr_debug("No Memory for session\n");
                return -1;
@@ -1672,7 +1671,8 @@ int cmd_sched(int argc, const char **argv, const char *prefix __maybe_unused)
                        .sample          = perf_sched__process_tracepoint_sample,
                        .comm            = perf_event__process_comm,
                        .lost            = perf_event__process_lost,
-                       .fork            = perf_event__process_task,
+                       .exit            = perf_event__process_exit,
+                       .fork            = perf_event__process_fork,
                        .ordered_samples = true,
                },
                .cmp_pid              = LIST_HEAD_INIT(sched.cmp_pid),
@@ -1707,7 +1707,7 @@ int cmd_sched(int argc, const char **argv, const char *prefix __maybe_unused)
        OPT_END()
        };
        const struct option sched_options[] = {
-       OPT_STRING('i', "input", &sched.input_name, "file",
+       OPT_STRING('i', "input", &input_name, "file",
                    "input file name"),
        OPT_INCR('v', "verbose", &verbose,
                    "be more verbose (show symbol address, etc)"),
index fb96250..b363e7b 100644 (file)
@@ -520,8 +520,8 @@ static struct perf_tool perf_script = {
        .sample          = process_sample_event,
        .mmap            = perf_event__process_mmap,
        .comm            = perf_event__process_comm,
-       .exit            = perf_event__process_task,
-       .fork            = perf_event__process_task,
+       .exit            = perf_event__process_exit,
+       .fork            = perf_event__process_fork,
        .attr            = perf_event__process_attr,
        .event_type      = perf_event__process_event_type,
        .tracing_data    = perf_event__process_tracing_data,
@@ -1030,6 +1030,68 @@ static int list_available_scripts(const struct option *opt __maybe_unused,
 }
 
 /*
+ * Some scripts specify the required events in their "xxx-record" file,
+ * this function will check if the events in perf.data match those
+ * mentioned in the "xxx-record".
+ *
+ * Fixme: All existing "xxx-record" are all in good formats "-e event ",
+ * which is covered well now. And new parsing code should be added to
+ * cover the future complexing formats like event groups etc.
+ */
+static int check_ev_match(char *dir_name, char *scriptname,
+                       struct perf_session *session)
+{
+       char filename[MAXPATHLEN], evname[128];
+       char line[BUFSIZ], *p;
+       struct perf_evsel *pos;
+       int match, len;
+       FILE *fp;
+
+       sprintf(filename, "%s/bin/%s-record", dir_name, scriptname);
+
+       fp = fopen(filename, "r");
+       if (!fp)
+               return -1;
+
+       while (fgets(line, sizeof(line), fp)) {
+               p = ltrim(line);
+               if (*p == '#')
+                       continue;
+
+               while (strlen(p)) {
+                       p = strstr(p, "-e");
+                       if (!p)
+                               break;
+
+                       p += 2;
+                       p = ltrim(p);
+                       len = strcspn(p, " \t");
+                       if (!len)
+                               break;
+
+                       snprintf(evname, len + 1, "%s", p);
+
+                       match = 0;
+                       list_for_each_entry(pos,
+                                       &session->evlist->entries, node) {
+                               if (!strcmp(perf_evsel__name(pos), evname)) {
+                                       match = 1;
+                                       break;
+                               }
+                       }
+
+                       if (!match) {
+                               fclose(fp);
+                               return -1;
+                       }
+               }
+       }
+
+       fclose(fp);
+       return 0;
+}
+
+/*
  * Return -1 if none is found, otherwise the actual scripts number.
  *
  * Currently the only user of this function is the script browser, which
@@ -1039,17 +1101,23 @@ static int list_available_scripts(const struct option *opt __maybe_unused,
 int find_scripts(char **scripts_array, char **scripts_path_array)
 {
        struct dirent *script_next, *lang_next, script_dirent, lang_dirent;
-       char scripts_path[MAXPATHLEN];
+       char scripts_path[MAXPATHLEN], lang_path[MAXPATHLEN];
        DIR *scripts_dir, *lang_dir;
-       char lang_path[MAXPATHLEN];
+       struct perf_session *session;
        char *temp;
        int i = 0;
 
+       session = perf_session__new(input_name, O_RDONLY, 0, false, NULL);
+       if (!session)
+               return -1;
+
        snprintf(scripts_path, MAXPATHLEN, "%s/scripts", perf_exec_path());
 
        scripts_dir = opendir(scripts_path);
-       if (!scripts_dir)
+       if (!scripts_dir) {
+               perf_session__delete(session);
                return -1;
+       }
 
        for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next) {
                snprintf(lang_path, MAXPATHLEN, "%s/%s", scripts_path,
@@ -1077,10 +1145,18 @@ int find_scripts(char **scripts_array, char **scripts_path_array)
                        snprintf(scripts_array[i],
                                (temp - script_dirent.d_name) + 1,
                                "%s", script_dirent.d_name);
+
+                       if (check_ev_match(lang_path,
+                                       scripts_array[i], session))
+                               continue;
+
                        i++;
                }
+               closedir(lang_dir);
        }
 
+       closedir(scripts_dir);
+       perf_session__delete(session);
        return i;
 }
 
@@ -1175,7 +1251,6 @@ static int have_cmd(int argc, const char **argv)
 int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
 {
        bool show_full_info = false;
-       const char *input_name = NULL;
        char *rec_script_path = NULL;
        char *rep_script_path = NULL;
        struct perf_session *session;
index 93b9011..c247fac 100644 (file)
@@ -57,6 +57,7 @@
 #include "util/thread.h"
 #include "util/thread_map.h"
 
+#include <stdlib.h>
 #include <sys/prctl.h>
 #include <locale.h>
 
@@ -83,6 +84,9 @@ static const char             *csv_sep                        = NULL;
 static bool                    csv_output                      = false;
 static bool                    group                           = false;
 static FILE                    *output                         = NULL;
+static const char              *pre_cmd                        = NULL;
+static const char              *post_cmd                       = NULL;
+static bool                    sync_run                        = false;
 
 static volatile int done = 0;
 
@@ -125,8 +129,7 @@ static struct stats runtime_itlb_cache_stats[MAX_NR_CPUS];
 static struct stats runtime_dtlb_cache_stats[MAX_NR_CPUS];
 static struct stats walltime_nsecs_stats;
 
-static int create_perf_stat_counter(struct perf_evsel *evsel,
-                                   struct perf_evsel *first)
+static int create_perf_stat_counter(struct perf_evsel *evsel)
 {
        struct perf_event_attr *attr = &evsel->attr;
        bool exclude_guest_missing = false;
@@ -149,7 +152,8 @@ retry:
                return 0;
        }
 
-       if (!perf_target__has_task(&target) && (!group || evsel == first)) {
+       if (!perf_target__has_task(&target) &&
+           !perf_evsel__is_group_member(evsel)) {
                attr->disabled = 1;
                attr->enable_on_exec = 1;
        }
@@ -265,10 +269,10 @@ static int read_counter(struct perf_evsel *counter)
        return 0;
 }
 
-static int run_perf_stat(int argc __maybe_unused, const char **argv)
+static int __run_perf_stat(int argc __maybe_unused, const char **argv)
 {
        unsigned long long t0, t1;
-       struct perf_evsel *counter, *first;
+       struct perf_evsel *counter;
        int status = 0;
        int child_ready_pipe[2], go_pipe[2];
        const bool forks = (argc > 0);
@@ -328,10 +332,8 @@ static int run_perf_stat(int argc __maybe_unused, const char **argv)
        if (group)
                perf_evlist__set_leader(evsel_list);
 
-       first = perf_evlist__first(evsel_list);
-
        list_for_each_entry(counter, &evsel_list->entries, node) {
-               if (create_perf_stat_counter(counter, first) < 0) {
+               if (create_perf_stat_counter(counter) < 0) {
                        /*
                         * PPC returns ENXIO for HW counters until 2.6.37
                         * (behavior changed with commit b0a873e).
@@ -405,6 +407,32 @@ static int run_perf_stat(int argc __maybe_unused, const char **argv)
        return WEXITSTATUS(status);
 }
 
+static int run_perf_stat(int argc __maybe_unused, const char **argv)
+{
+       int ret;
+
+       if (pre_cmd) {
+               ret = system(pre_cmd);
+               if (ret)
+                       return ret;
+       }
+
+       if (sync_run)
+               sync();
+
+       ret = __run_perf_stat(argc, argv);
+       if (ret)
+               return ret;
+
+       if (post_cmd) {
+               ret = system(post_cmd);
+               if (ret)
+                       return ret;
+       }
+
+       return ret;
+}
+
 static void print_noise_pct(double total, double avg)
 {
        double pct = rel_stddev_stats(total, avg);
@@ -1069,8 +1097,7 @@ static int add_default_attributes(void)
 
 int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
 {
-       bool append_file = false,
-            sync_run = false;
+       bool append_file = false;
        int output_fd = 0;
        const char *output_name = NULL;
        const struct option options[] = {
@@ -1114,6 +1141,10 @@ int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
        OPT_BOOLEAN(0, "append", &append_file, "append to the output file"),
        OPT_INTEGER(0, "log-fd", &output_fd,
                    "log output to fd, instead of stderr"),
+       OPT_STRING(0, "pre", &pre_cmd, "command",
+                       "command to run prior to the measured command"),
+       OPT_STRING(0, "post", &post_cmd, "command",
+                       "command to run after to the measured command"),
        OPT_END()
        };
        const char * const stat_usage[] = {
@@ -1238,9 +1269,6 @@ int cmd_stat(int argc, const char **argv, const char *prefix __maybe_unused)
                        fprintf(output, "[ perf stat: executing run #%d ... ]\n",
                                run_idx + 1);
 
-               if (sync_run)
-                       sync();
-
                status = run_perf_stat(argc, argv);
        }
 
diff --git a/tools/perf/builtin-test.c b/tools/perf/builtin-test.c
deleted file mode 100644 (file)
index 5acd6e8..0000000
+++ /dev/null
@@ -1,1547 +0,0 @@
-/*
- * builtin-test.c
- *
- * Builtin regression testing command: ever growing number of sanity tests
- */
-#include "builtin.h"
-
-#include "util/cache.h"
-#include "util/debug.h"
-#include "util/debugfs.h"
-#include "util/evlist.h"
-#include "util/parse-options.h"
-#include "util/parse-events.h"
-#include "util/symbol.h"
-#include "util/thread_map.h"
-#include "util/pmu.h"
-#include "event-parse.h"
-#include <linux/hw_breakpoint.h>
-
-#include <sys/mman.h>
-
-static int vmlinux_matches_kallsyms_filter(struct map *map __maybe_unused,
-                                          struct symbol *sym)
-{
-       bool *visited = symbol__priv(sym);
-       *visited = true;
-       return 0;
-}
-
-static int test__vmlinux_matches_kallsyms(void)
-{
-       int err = -1;
-       struct rb_node *nd;
-       struct symbol *sym;
-       struct map *kallsyms_map, *vmlinux_map;
-       struct machine kallsyms, vmlinux;
-       enum map_type type = MAP__FUNCTION;
-       long page_size = sysconf(_SC_PAGE_SIZE);
-       struct ref_reloc_sym ref_reloc_sym = { .name = "_stext", };
-
-       /*
-        * Step 1:
-        *
-        * Init the machines that will hold kernel, modules obtained from
-        * both vmlinux + .ko files and from /proc/kallsyms split by modules.
-        */
-       machine__init(&kallsyms, "", HOST_KERNEL_ID);
-       machine__init(&vmlinux, "", HOST_KERNEL_ID);
-
-       /*
-        * Step 2:
-        *
-        * Create the kernel maps for kallsyms and the DSO where we will then
-        * load /proc/kallsyms. Also create the modules maps from /proc/modules
-        * and find the .ko files that match them in /lib/modules/`uname -r`/.
-        */
-       if (machine__create_kernel_maps(&kallsyms) < 0) {
-               pr_debug("machine__create_kernel_maps ");
-               return -1;
-       }
-
-       /*
-        * Step 3:
-        *
-        * Load and split /proc/kallsyms into multiple maps, one per module.
-        */
-       if (machine__load_kallsyms(&kallsyms, "/proc/kallsyms", type, NULL) <= 0) {
-               pr_debug("dso__load_kallsyms ");
-               goto out;
-       }
-
-       /*
-        * Step 4:
-        *
-        * kallsyms will be internally on demand sorted by name so that we can
-        * find the reference relocation * symbol, i.e. the symbol we will use
-        * to see if the running kernel was relocated by checking if it has the
-        * same value in the vmlinux file we load.
-        */
-       kallsyms_map = machine__kernel_map(&kallsyms, type);
-
-       sym = map__find_symbol_by_name(kallsyms_map, ref_reloc_sym.name, NULL);
-       if (sym == NULL) {
-               pr_debug("dso__find_symbol_by_name ");
-               goto out;
-       }
-
-       ref_reloc_sym.addr = sym->start;
-
-       /*
-        * Step 5:
-        *
-        * Now repeat step 2, this time for the vmlinux file we'll auto-locate.
-        */
-       if (machine__create_kernel_maps(&vmlinux) < 0) {
-               pr_debug("machine__create_kernel_maps ");
-               goto out;
-       }
-
-       vmlinux_map = machine__kernel_map(&vmlinux, type);
-       map__kmap(vmlinux_map)->ref_reloc_sym = &ref_reloc_sym;
-
-       /*
-        * Step 6:
-        *
-        * Locate a vmlinux file in the vmlinux path that has a buildid that
-        * matches the one of the running kernel.
-        *
-        * While doing that look if we find the ref reloc symbol, if we find it
-        * we'll have its ref_reloc_symbol.unrelocated_addr and then
-        * maps__reloc_vmlinux will notice and set proper ->[un]map_ip routines
-        * to fixup the symbols.
-        */
-       if (machine__load_vmlinux_path(&vmlinux, type,
-                                      vmlinux_matches_kallsyms_filter) <= 0) {
-               pr_debug("machine__load_vmlinux_path ");
-               goto out;
-       }
-
-       err = 0;
-       /*
-        * Step 7:
-        *
-        * Now look at the symbols in the vmlinux DSO and check if we find all of them
-        * in the kallsyms dso. For the ones that are in both, check its names and
-        * end addresses too.
-        */
-       for (nd = rb_first(&vmlinux_map->dso->symbols[type]); nd; nd = rb_next(nd)) {
-               struct symbol *pair, *first_pair;
-               bool backwards = true;
-
-               sym  = rb_entry(nd, struct symbol, rb_node);
-
-               if (sym->start == sym->end)
-                       continue;
-
-               first_pair = machine__find_kernel_symbol(&kallsyms, type, sym->start, NULL, NULL);
-               pair = first_pair;
-
-               if (pair && pair->start == sym->start) {
-next_pair:
-                       if (strcmp(sym->name, pair->name) == 0) {
-                               /*
-                                * kallsyms don't have the symbol end, so we
-                                * set that by using the next symbol start - 1,
-                                * in some cases we get this up to a page
-                                * wrong, trace_kmalloc when I was developing
-                                * this code was one such example, 2106 bytes
-                                * off the real size. More than that and we
-                                * _really_ have a problem.
-                                */
-                               s64 skew = sym->end - pair->end;
-                               if (llabs(skew) < page_size)
-                                       continue;
-
-                               pr_debug("%#" PRIx64 ": diff end addr for %s v: %#" PRIx64 " k: %#" PRIx64 "\n",
-                                        sym->start, sym->name, sym->end, pair->end);
-                       } else {
-                               struct rb_node *nnd;
-detour:
-                               nnd = backwards ? rb_prev(&pair->rb_node) :
-                                                 rb_next(&pair->rb_node);
-                               if (nnd) {
-                                       struct symbol *next = rb_entry(nnd, struct symbol, rb_node);
-
-                                       if (next->start == sym->start) {
-                                               pair = next;
-                                               goto next_pair;
-                                       }
-                               }
-
-                               if (backwards) {
-                                       backwards = false;
-                                       pair = first_pair;
-                                       goto detour;
-                               }
-
-                               pr_debug("%#" PRIx64 ": diff name v: %s k: %s\n",
-                                        sym->start, sym->name, pair->name);
-                       }
-               } else
-                       pr_debug("%#" PRIx64 ": %s not on kallsyms\n", sym->start, sym->name);
-
-               err = -1;
-       }
-
-       if (!verbose)
-               goto out;
-
-       pr_info("Maps only in vmlinux:\n");
-
-       for (nd = rb_first(&vmlinux.kmaps.maps[type]); nd; nd = rb_next(nd)) {
-               struct map *pos = rb_entry(nd, struct map, rb_node), *pair;
-               /*
-                * If it is the kernel, kallsyms is always "[kernel.kallsyms]", while
-                * the kernel will have the path for the vmlinux file being used,
-                * so use the short name, less descriptive but the same ("[kernel]" in
-                * both cases.
-                */
-               pair = map_groups__find_by_name(&kallsyms.kmaps, type,
-                                               (pos->dso->kernel ?
-                                                       pos->dso->short_name :
-                                                       pos->dso->name));
-               if (pair)
-                       pair->priv = 1;
-               else
-                       map__fprintf(pos, stderr);
-       }
-
-       pr_info("Maps in vmlinux with a different name in kallsyms:\n");
-
-       for (nd = rb_first(&vmlinux.kmaps.maps[type]); nd; nd = rb_next(nd)) {
-               struct map *pos = rb_entry(nd, struct map, rb_node), *pair;
-
-               pair = map_groups__find(&kallsyms.kmaps, type, pos->start);
-               if (pair == NULL || pair->priv)
-                       continue;
-
-               if (pair->start == pos->start) {
-                       pair->priv = 1;
-                       pr_info(" %" PRIx64 "-%" PRIx64 " %" PRIx64 " %s in kallsyms as",
-                               pos->start, pos->end, pos->pgoff, pos->dso->name);
-                       if (pos->pgoff != pair->pgoff || pos->end != pair->end)
-                               pr_info(": \n*%" PRIx64 "-%" PRIx64 " %" PRIx64 "",
-                                       pair->start, pair->end, pair->pgoff);
-                       pr_info(" %s\n", pair->dso->name);
-                       pair->priv = 1;
-               }
-       }
-
-       pr_info("Maps only in kallsyms:\n");
-
-       for (nd = rb_first(&kallsyms.kmaps.maps[type]);
-            nd; nd = rb_next(nd)) {
-               struct map *pos = rb_entry(nd, struct map, rb_node);
-
-               if (!pos->priv)
-                       map__fprintf(pos, stderr);
-       }
-out:
-       return err;
-}
-
-#include "util/cpumap.h"
-#include "util/evsel.h"
-#include <sys/types.h>
-
-static int trace_event__id(const char *evname)
-{
-       char *filename;
-       int err = -1, fd;
-
-       if (asprintf(&filename,
-                    "%s/syscalls/%s/id",
-                    tracing_events_path, evname) < 0)
-               return -1;
-
-       fd = open(filename, O_RDONLY);
-       if (fd >= 0) {
-               char id[16];
-               if (read(fd, id, sizeof(id)) > 0)
-                       err = atoi(id);
-               close(fd);
-       }
-
-       free(filename);
-       return err;
-}
-
-static int test__open_syscall_event(void)
-{
-       int err = -1, fd;
-       struct thread_map *threads;
-       struct perf_evsel *evsel;
-       struct perf_event_attr attr;
-       unsigned int nr_open_calls = 111, i;
-       int id = trace_event__id("sys_enter_open");
-
-       if (id < 0) {
-               pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
-               return -1;
-       }
-
-       threads = thread_map__new(-1, getpid(), UINT_MAX);
-       if (threads == NULL) {
-               pr_debug("thread_map__new\n");
-               return -1;
-       }
-
-       memset(&attr, 0, sizeof(attr));
-       attr.type = PERF_TYPE_TRACEPOINT;
-       attr.config = id;
-       evsel = perf_evsel__new(&attr, 0);
-       if (evsel == NULL) {
-               pr_debug("perf_evsel__new\n");
-               goto out_thread_map_delete;
-       }
-
-       if (perf_evsel__open_per_thread(evsel, threads) < 0) {
-               pr_debug("failed to open counter: %s, "
-                        "tweak /proc/sys/kernel/perf_event_paranoid?\n",
-                        strerror(errno));
-               goto out_evsel_delete;
-       }
-
-       for (i = 0; i < nr_open_calls; ++i) {
-               fd = open("/etc/passwd", O_RDONLY);
-               close(fd);
-       }
-
-       if (perf_evsel__read_on_cpu(evsel, 0, 0) < 0) {
-               pr_debug("perf_evsel__read_on_cpu\n");
-               goto out_close_fd;
-       }
-
-       if (evsel->counts->cpu[0].val != nr_open_calls) {
-               pr_debug("perf_evsel__read_on_cpu: expected to intercept %d calls, got %" PRIu64 "\n",
-                        nr_open_calls, evsel->counts->cpu[0].val);
-               goto out_close_fd;
-       }
-       
-       err = 0;
-out_close_fd:
-       perf_evsel__close_fd(evsel, 1, threads->nr);
-out_evsel_delete:
-       perf_evsel__delete(evsel);
-out_thread_map_delete:
-       thread_map__delete(threads);
-       return err;
-}
-
-#include <sched.h>
-
-static int test__open_syscall_event_on_all_cpus(void)
-{
-       int err = -1, fd, cpu;
-       struct thread_map *threads;
-       struct cpu_map *cpus;
-       struct perf_evsel *evsel;
-       struct perf_event_attr attr;
-       unsigned int nr_open_calls = 111, i;
-       cpu_set_t cpu_set;
-       int id = trace_event__id("sys_enter_open");
-
-       if (id < 0) {
-               pr_debug("is debugfs mounted on /sys/kernel/debug?\n");
-               return -1;
-       }
-
-       threads = thread_map__new(-1, getpid(), UINT_MAX);
-       if (threads == NULL) {
-               pr_debug("thread_map__new\n");
-               return -1;
-       }
-
-       cpus = cpu_map__new(NULL);
-       if (cpus == NULL) {
-               pr_debug("cpu_map__new\n");
-               goto out_thread_map_delete;
-       }
-
-
-       CPU_ZERO(&cpu_set);
-
-       memset(&attr, 0, sizeof(attr));
-       attr.type = PERF_TYPE_TRACEPOINT;
-       attr.config = id;
-       evsel = perf_evsel__new(&attr, 0);
-       if (evsel == NULL) {
-               pr_debug("perf_evsel__new\n");
-               goto out_thread_map_delete;
-       }
-
-       if (perf_evsel__open(evsel, cpus, threads) < 0) {
-               pr_debug("failed to open counter: %s, "
-                        "tweak /proc/sys/kernel/perf_event_paranoid?\n",
-                        strerror(errno));
-               goto out_evsel_delete;
-       }
-
-       for (cpu = 0; cpu < cpus->nr; ++cpu) {
-               unsigned int ncalls = nr_open_calls + cpu;
-               /*
-                * XXX eventually lift this restriction in a way that
-                * keeps perf building on older glibc installations
-                * without CPU_ALLOC. 1024 cpus in 2010 still seems
-                * a reasonable upper limit tho :-)
-                */
-               if (cpus->map[cpu] >= CPU_SETSIZE) {
-                       pr_debug("Ignoring CPU %d\n", cpus->map[cpu]);
-                       continue;
-               }
-
-               CPU_SET(cpus->map[cpu], &cpu_set);
-               if (sched_setaffinity(0, sizeof(cpu_set), &cpu_set) < 0) {
-                       pr_debug("sched_setaffinity() failed on CPU %d: %s ",
-                                cpus->map[cpu],
-                                strerror(errno));
-                       goto out_close_fd;
-               }
-               for (i = 0; i < ncalls; ++i) {
-                       fd = open("/etc/passwd", O_RDONLY);
-                       close(fd);
-               }
-               CPU_CLR(cpus->map[cpu], &cpu_set);
-       }
-
-       /*
-        * Here we need to explicitely preallocate the counts, as if
-        * we use the auto allocation it will allocate just for 1 cpu,
-        * as we start by cpu 0.
-        */
-       if (perf_evsel__alloc_counts(evsel, cpus->nr) < 0) {
-               pr_debug("perf_evsel__alloc_counts(ncpus=%d)\n", cpus->nr);
-               goto out_close_fd;
-       }
-
-       err = 0;
-
-       for (cpu = 0; cpu < cpus->nr; ++cpu) {
-               unsigned int expected;
-
-               if (cpus->map[cpu] >= CPU_SETSIZE)
-                       continue;
-
-               if (perf_evsel__read_on_cpu(evsel, cpu, 0) < 0) {
-                       pr_debug("perf_evsel__read_on_cpu\n");
-                       err = -1;
-                       break;
-               }
-
-               expected = nr_open_calls + cpu;
-               if (evsel->counts->cpu[cpu].val != expected) {
-                       pr_debug("perf_evsel__read_on_cpu: expected to intercept %d calls on cpu %d, got %" PRIu64 "\n",
-                                expected, cpus->map[cpu], evsel->counts->cpu[cpu].val);
-                       err = -1;
-               }
-       }
-
-out_close_fd:
-       perf_evsel__close_fd(evsel, 1, threads->nr);
-out_evsel_delete:
-       perf_evsel__delete(evsel);
-out_thread_map_delete:
-       thread_map__delete(threads);
-       return err;
-}
-
-/*
- * This test will generate random numbers of calls to some getp