[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Xen-devel] [PATCH v1 3/5] xen/PMU: Initialization code for Xen PMU



Map shared data structure that will hold CPU registers, VPMU context,
VCPU/PCPI IDs of the VCPU interrupted by PMU interrupt. Hypervisor
fills this information in its handler and passes it to the guest for
further processing.

Set up PMU VIRQ.

Signed-off-by: Boris Ostrovsky <boris.ostrovsky@xxxxxxxxxx>
---
 arch/x86/xen/Makefile          |   2 +-
 arch/x86/xen/pmu.c             | 122 +++++++++++++++++++++++++++++++++++++++++
 arch/x86/xen/pmu.h             |  12 ++++
 arch/x86/xen/smp.c             |  31 ++++++++++-
 include/xen/interface/xen.h    |   1 +
 include/xen/interface/xenpmu.h |  77 ++++++++++++++++++++++++++
 6 files changed, 243 insertions(+), 2 deletions(-)
 create mode 100644 arch/x86/xen/pmu.c
 create mode 100644 arch/x86/xen/pmu.h

diff --git a/arch/x86/xen/Makefile b/arch/x86/xen/Makefile
index 96ab2c0..b187df5 100644
--- a/arch/x86/xen/Makefile
+++ b/arch/x86/xen/Makefile
@@ -13,7 +13,7 @@ CFLAGS_mmu.o                  := $(nostackp)
 obj-y          := enlighten.o setup.o multicalls.o mmu.o irq.o \
                        time.o xen-asm.o xen-asm_$(BITS).o \
                        grant-table.o suspend.o platform-pci-unplug.o \
-                       p2m.o
+                       p2m.o pmu.o
 
 obj-$(CONFIG_EVENT_TRACING) += trace.o
 
diff --git a/arch/x86/xen/pmu.c b/arch/x86/xen/pmu.c
new file mode 100644
index 0000000..da061d4
--- /dev/null
+++ b/arch/x86/xen/pmu.c
@@ -0,0 +1,122 @@
+#include <linux/types.h>
+#include <linux/interrupt.h>
+
+#include <asm/xen/hypercall.h>
+#include <xen/page.h>
+#include <xen/interface/xen.h>
+#include <xen/interface/vcpu.h>
+#include <xen/interface/xenpmu.h>
+
+#include "xen-ops.h"
+#include "pmu.h"
+
+/* x86_pmu.handle_irq definition */
+#include <../kernel/cpu/perf_event.h>
+
+
+/* Shared page between hypervisor and domain */
+DEFINE_PER_CPU(struct xenpmu_data *, xenpmu_shared);
+
+/* perf callbacks*/
+int xen_is_in_guest(void)
+{
+       struct xenpmu_data *xenpmu_data = per_cpu(xenpmu_shared,
+                                                 smp_processor_id());
+
+       if (!xen_initial_domain() ||
+           xenpmu_data->domain_id > DOMID_SELF || xenpmu_data->domain_id == 0)
+               return 0;
+
+       return 1;
+}
+
+static int xen_is_user_mode(void)
+{
+       struct xenpmu_data *xenpmu_data = per_cpu(xenpmu_shared,
+                                                 smp_processor_id());
+       return ((xenpmu_data->regs.cs & 3) == 3);
+}
+
+static unsigned long xen_get_guest_ip(void)
+{
+       struct xenpmu_data *xenpmu_data = per_cpu(xenpmu_shared,
+                                                 smp_processor_id());
+       return xenpmu_data->regs.eip;
+}
+
+static struct perf_guest_info_callbacks xen_guest_cbs = {
+       .is_in_guest            = xen_is_in_guest,
+       .is_user_mode           = xen_is_user_mode,
+       .get_guest_ip           = xen_get_guest_ip,
+};
+
+/* Convert registers from Xen's format to Linux' */
+static void xen_convert_regs(struct cpu_user_regs *xen_regs,
+                            struct pt_regs *regs)
+{
+       regs->ip = xen_regs->eip;
+       regs->cs = xen_regs->cs;
+}
+
+irqreturn_t xen_pmu_irq_handler(int irq, void *dev_id)
+{
+       int ret = IRQ_NONE;
+       struct pt_regs regs;
+       struct xenpmu_data *xenpmu_data = per_cpu(xenpmu_shared,
+                                                 smp_processor_id());
+
+       xen_convert_regs(&xenpmu_data->regs, &regs);
+       if (x86_pmu.handle_irq(&regs))
+               ret = IRQ_HANDLED;
+
+       return ret;
+}
+
+int xen_pmu_init(int cpu)
+{
+       int ret = 0;
+       struct xenpmu_params xp;
+       unsigned long pfn;
+       struct xenpmu_data *xenpmu_data;
+
+       BUILD_BUG_ON(sizeof(struct xenpmu_data) > PAGE_SIZE);
+       xenpmu_data = vmalloc(PAGE_SIZE);
+       if (!xenpmu_data) {
+               ret = -ENOMEM;
+               goto fail;
+       }
+       pfn = vmalloc_to_pfn((char *)xenpmu_data);
+
+       xp.mfn = pfn_to_mfn(pfn);
+       xp.vcpu = cpu;
+       xp.version.maj = XENPMU_VER_MAJ;
+       xp.version.min = XENPMU_VER_MIN;
+       ret = HYPERVISOR_xenpmu_op(XENPMU_init, &xp);
+       if (ret)
+               goto fail;
+
+       per_cpu(xenpmu_shared, cpu) = xenpmu_data;
+
+       if (cpu == 0)
+               perf_register_guest_info_callbacks(&xen_guest_cbs);
+
+       return ret;
+
+fail:
+       vfree(xenpmu_data);
+       return ret;
+}
+
+void xen_pmu_finish(int cpu)
+{
+       struct xenpmu_params xp;
+
+       xp.vcpu = cpu;
+       xp.version.maj = XENPMU_VER_MAJ;
+       xp.version.min = XENPMU_VER_MIN;
+
+       (void)HYPERVISOR_xenpmu_op(XENPMU_finish, &xp);
+
+       vfree(per_cpu(xenpmu_shared, cpu));
+       per_cpu(xenpmu_shared, cpu) = NULL;
+}
diff --git a/arch/x86/xen/pmu.h b/arch/x86/xen/pmu.h
new file mode 100644
index 0000000..51de7d2
--- /dev/null
+++ b/arch/x86/xen/pmu.h
@@ -0,0 +1,12 @@
+#ifndef __XEN_PMU_H
+#define __XEN_PMU_H
+
+#include <xen/interface/xenpmu.h>
+
+irqreturn_t xen_pmu_irq_handler(int irq, void *dev_id);
+int xen_pmu_init(int cpu);
+void xen_pmu_finish(int cpu);
+
+DECLARE_PER_CPU(struct xenpmu_data *, xenpmu_shared);
+
+#endif /* __XEN_PMU_H */
diff --git a/arch/x86/xen/smp.c b/arch/x86/xen/smp.c
index ca92754..17a88d1 100644
--- a/arch/x86/xen/smp.c
+++ b/arch/x86/xen/smp.c
@@ -26,6 +26,7 @@
 
 #include <xen/interface/xen.h>
 #include <xen/interface/vcpu.h>
+#include <xen/interface/xenpmu.h>
 
 #include <asm/xen/interface.h>
 #include <asm/xen/hypercall.h>
@@ -37,6 +38,7 @@
 #include <xen/hvc-console.h>
 #include "xen-ops.h"
 #include "mmu.h"
+#include "pmu.h"
 
 cpumask_var_t xen_cpu_initialized_map;
 
@@ -49,6 +51,7 @@ static DEFINE_PER_CPU(struct xen_common_irq, 
xen_callfunc_irq) = { .irq = -1 };
 static DEFINE_PER_CPU(struct xen_common_irq, xen_callfuncsingle_irq) = { .irq 
= -1 };
 static DEFINE_PER_CPU(struct xen_common_irq, xen_irq_work) = { .irq = -1 };
 static DEFINE_PER_CPU(struct xen_common_irq, xen_debug_irq) = { .irq = -1 };
+static DEFINE_PER_CPU(struct xen_common_irq, xen_pmu_irq) = { .irq = -1 };
 
 static irqreturn_t xen_call_function_interrupt(int irq, void *dev_id);
 static irqreturn_t xen_call_function_single_interrupt(int irq, void *dev_id);
@@ -139,11 +142,18 @@ static void xen_smp_intr_free(unsigned int cpu)
                kfree(per_cpu(xen_irq_work, cpu).name);
                per_cpu(xen_irq_work, cpu).name = NULL;
        }
+
+       if (per_cpu(xen_pmu_irq, cpu).irq >= 0) {
+               unbind_from_irqhandler(per_cpu(xen_pmu_irq, cpu).irq, NULL);
+               per_cpu(xen_pmu_irq, cpu).irq = -1;
+               kfree(per_cpu(xen_pmu_irq, cpu).name);
+               per_cpu(xen_pmu_irq, cpu).name = NULL;
+       }
 };
 static int xen_smp_intr_init(unsigned int cpu)
 {
        int rc;
-       char *resched_name, *callfunc_name, *debug_name;
+       char *resched_name, *callfunc_name, *debug_name, *pmu_name;
 
        resched_name = kasprintf(GFP_KERNEL, "resched%d", cpu);
        rc = bind_ipi_to_irqhandler(XEN_RESCHEDULE_VECTOR,
@@ -209,6 +219,18 @@ static int xen_smp_intr_init(unsigned int cpu)
        per_cpu(xen_irq_work, cpu).irq = rc;
        per_cpu(xen_irq_work, cpu).name = callfunc_name;
 
+       if (per_cpu(xenpmu_shared, cpu)) {
+               pmu_name = kasprintf(GFP_KERNEL, "pmu%d", cpu);
+               rc = bind_virq_to_irqhandler(VIRQ_XENPMU, cpu,
+                                            xen_pmu_irq_handler,
+                                            IRQF_PERCPU|IRQF_NOBALANCING,
+                                            pmu_name, NULL);
+               if (rc < 0)
+                       goto fail;
+               per_cpu(xen_pmu_irq, cpu).irq = rc;
+               per_cpu(xen_pmu_irq, cpu).name = pmu_name;
+       }
+
        return 0;
 
  fail:
@@ -307,6 +329,9 @@ static void __init xen_smp_prepare_cpus(unsigned int 
max_cpus)
        }
        set_cpu_sibling_map(0);
 
+       if (xen_pmu_init(0))
+               pr_err("Could not initialize VPMU for VCPU 0\n");
+
        if (xen_smp_intr_init(0))
                BUG();
 
@@ -427,6 +452,9 @@ static int xen_cpu_up(unsigned int cpu, struct task_struct 
*idle)
                /* Just in case we booted with a single CPU. */
                alternatives_enable_smp();
 
+       if (xen_pmu_init(cpu))
+               pr_err("Could not initialize VPMU for VCPU %u\n", cpu);
+
        rc = xen_smp_intr_init(cpu);
        if (rc)
                return rc;
@@ -468,6 +496,7 @@ static void xen_cpu_die(unsigned int cpu)
        xen_smp_intr_free(cpu);
        xen_uninit_lock_cpu(cpu);
        xen_teardown_timer(cpu);
+       xen_pmu_finish(cpu);
 }
 
 static void xen_play_dead(void) /* used only with HOTPLUG_CPU */
diff --git a/include/xen/interface/xen.h b/include/xen/interface/xen.h
index c29d427..74eb6f3 100644
--- a/include/xen/interface/xen.h
+++ b/include/xen/interface/xen.h
@@ -81,6 +81,7 @@
 #define VIRQ_DOM_EXC    3  /* (DOM0) Exceptional event for some domain.   */
 #define VIRQ_DEBUGGER   6  /* (DOM0) A domain has paused for debugging.   */
 #define VIRQ_PCPU_STATE 9  /* (DOM0) PCPU state changed                   */
+#define VIRQ_XENPMU    13  /* PMC interrupt                               */
 
 /* Architecture-specific VIRQ definitions. */
 #define VIRQ_ARCH_0    16
diff --git a/include/xen/interface/xenpmu.h b/include/xen/interface/xenpmu.h
index 63c42b1..7af682d 100644
--- a/include/xen/interface/xenpmu.h
+++ b/include/xen/interface/xenpmu.h
@@ -13,6 +13,8 @@
 #define XENPMU_mode_set        1
 #define XENPMU_flags_get       2
 #define XENPMU_flags_set       3
+#define XENPMU_init            4
+#define XENPMU_finish          5
 
 /* Parameter structure for HYPERVISOR_xenpmu_op call */
 struct xenpmu_params {
@@ -24,6 +26,8 @@ struct xenpmu_params {
                uint64_t pad;
        };
        uint64_t control;
+       uint64_t mfn;
+       uint64_t vcpu;
 };
 
 /* VPMU modes */
@@ -41,4 +45,77 @@ struct xenpmu_params {
 #define VPMU_FLAGS_MASK    ((uint32_t)(~VPMU_MODE_MASK))
 #define VPMU_INTEL_BTS     (1<<8) /* Ignored on AMD */
 
+
+/* AMD PMU registers and structures */
+#define F10H_NUM_COUNTERS   4
+#define F15H_NUM_COUNTERS   6
+/* To accommodate more countes in the future (e.g. NB counters) */
+#define MAX_NUM_COUNTERS    16
+struct amd_vpmu_context {
+       uint64_t counters[MAX_NUM_COUNTERS];
+       uint64_t ctrls[MAX_NUM_COUNTERS];
+       uint8_t msr_bitmap_set;
+};
+
+
+/* Intel PMU registers and structures */
+static const uint32_t core2_fix_counters_msr[] = {
+       MSR_CORE_PERF_FIXED_CTR0,
+       MSR_CORE_PERF_FIXED_CTR1,
+       MSR_CORE_PERF_FIXED_CTR2
+};
+#define VPMU_CORE2_NUM_FIXED (sizeof(core2_fix_counters_msr) / 
sizeof(uint32_t))
+
+/* Core 2 Non-architectual Performance Control MSRs. */
+static const uint32_t core2_ctrls_msr[] = {
+       MSR_CORE_PERF_FIXED_CTR_CTRL,
+       MSR_IA32_PEBS_ENABLE,
+       MSR_IA32_DS_AREA
+};
+#define VPMU_CORE2_NUM_CTRLS (sizeof(core2_ctrls_msr) / sizeof(uint32_t))
+
+#define VPMU_CORE2_MAX_ARCH_PMCS   16
+struct core2_pmu_enable {
+       char ds_area_enable;
+       char fixed_ctr_enable[VPMU_CORE2_NUM_FIXED];
+       char arch_pmc_enable[VPMU_CORE2_MAX_ARCH_PMCS];
+};
+
+struct arch_msr_pair {
+       uint64_t counter;
+       uint64_t control;
+};
+struct core2_vpmu_context {
+       uint64_t global_ctrl;
+       uint64_t global_ovf_ctrl;
+       uint64_t global_status;
+       uint64_t global_ovf_status;
+       uint64_t fix_counters[VPMU_CORE2_NUM_FIXED];
+       uint64_t ctrls[VPMU_CORE2_NUM_CTRLS];
+       struct arch_msr_pair arch_msr_pair[VPMU_CORE2_MAX_ARCH_PMCS];
+       struct core2_pmu_enable *pmu_enable;
+};
+
+/* Shared between hypervisor and PV domain */
+struct xenpmu_data {
+       union {
+               struct cpu_user_regs regs;
+               uint8_t pad[256];
+       };
+       uint32_t domain_id;
+       uint32_t vcpu_id;
+       uint32_t pcpu_id;
+       uint32_t pmu_flags;
+       union {
+               struct amd_vpmu_context amd;
+               struct core2_vpmu_context intel;
+#define MAX(x, y)       ((x) > (y) ? (x) : (y))
+#define MAX_CTXT_SZ     MAX(sizeof(struct amd_vpmu_context),\
+                           sizeof(struct core2_vpmu_context))
+#define PMU_PAD_SIZE    (((MAX_CTXT_SZ + 64) & ~63) + 128)
+               uint8_t pad[PMU_PAD_SIZE]; /* a bit more than necessary */
+       } pmu;
+};
+
+
 #endif /* __XEN_PUBLIC_XENPMU_H__ */
-- 
1.8.1.4


_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxx
http://lists.xen.org/xen-devel


 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.