10 files changed, 193 insertions, 42 deletions

diff --git a/arch/x86/kernel/Makefile b/arch/x86/kernel/Makefile
index 91ce48f05f9f..34e923a53762 100644
--- a/arch/x86/kernel/Makefile
+++ b/arch/x86/kernel/Makefile
@@ -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
diff --git a/arch/x86/kernel/cpu/perf_event.c b/arch/x86/kernel/cpu/perf_event.c
index 4a3374e61a93..4428fd178bce 100644
--- a/arch/x86/kernel/cpu/perf_event.c
+++ b/arch/x86/kernel/cpu/perf_event.c
@@ -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,
 };
 
diff --git a/arch/x86/kernel/cpu/perf_event.h b/arch/x86/kernel/cpu/perf_event.h
index 271d25700297..115c1ea97746 100644
--- a/arch/x86/kernel/cpu/perf_event.h
+++ b/arch/x86/kernel/cpu/perf_event.h
@@ -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);
diff --git a/arch/x86/kernel/cpu/perf_event_amd.c b/arch/x86/kernel/cpu/perf_event_amd.c
index 4528ae7b6ec4..c93bc4e813a0 100644
--- a/arch/x86/kernel/cpu/perf_event_amd.c
+++ b/arch/x86/kernel/cpu/perf_event_amd.c
@@ -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,
diff --git a/arch/x86/kernel/cpu/perf_event_intel.c b/arch/x86/kernel/cpu/perf_event_intel.c
index 324bb523d9d9..93b9e1181f83 100644
--- a/arch/x86/kernel/cpu/perf_event_intel.c
+++ b/arch/x86/kernel/cpu/perf_event_intel.c
@@ -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,
diff --git a/arch/x86/kernel/cpu/perf_event_p6.c b/arch/x86/kernel/cpu/perf_event_p6.c
index 7d0270bd793e..f2af39f5dc3d 100644
--- a/arch/x86/kernel/cpu/perf_event_p6.c
+++ b/arch/x86/kernel/cpu/perf_event_p6.c
@@ -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)
diff --git a/arch/x86/kernel/rtc.c b/arch/x86/kernel/rtc.c
index 4929c1be0ac0..801602b5d745 100644
--- a/arch/x86/kernel/rtc.c
+++ b/arch/x86/kernel/rtc.c
@@ -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
index 000000000000..25b993729f9b
--- /dev/null
+++ b/arch/x86/kernel/trace_clock.c
@@ -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;
+}
diff --git a/arch/x86/kernel/tsc.c b/arch/x86/kernel/tsc.c
index cfa5d4f7ca56..06ccb5073a3f 100644
--- a/arch/x86/kernel/tsc.c
+++ b/arch/x86/kernel/tsc.c
@@ -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;
diff --git a/arch/x86/kernel/uprobes.c b/arch/x86/kernel/uprobes.c
index aafa5557b396..c71025b67462 100644
--- a/arch/x86/kernel/uprobes.c
+++ b/arch/x86/kernel/uprobes.c
@@ -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;
-        }
-}