On Wed, Jul 27, 2022 at 1:11 AM Weiwei Li <[email protected]> wrote:
>
> 在 2022/7/27 下午2:49, Atish Patra 写道:
> > The Sscofpmf ('Ss' for Privileged arch and Supervisor-level extensions,
> > and 'cofpmf' for Count OverFlow and Privilege Mode Filtering)
> > extension allows the perf to handle overflow interrupts and filtering
> > support. This patch provides a framework for programmable
> > counters to leverage the extension. As the extension doesn't have any
> > provision for the overflow bit for fixed counters, the fixed events
> > can also be monitoring using programmable counters. The underlying
> > counters for cycle and instruction counters are always running. Thus,
> > a separate timer device is programmed to handle the overflow.
> >
> > Tested-by: Heiko Stuebner <[email protected]>
> > Signed-off-by: Atish Patra <[email protected]>
> > Signed-off-by: Atish Patra <[email protected]>
> > ---
> > target/riscv/cpu.c | 11 ++
> > target/riscv/cpu.h | 25 +++
> > target/riscv/cpu_bits.h | 55 +++++++
> > target/riscv/csr.c | 166 ++++++++++++++++++-
> > target/riscv/machine.c | 1 +
> > target/riscv/pmu.c | 357 +++++++++++++++++++++++++++++++++++++++-
> > target/riscv/pmu.h | 7 +
> > 7 files changed, 611 insertions(+), 11 deletions(-)
> >
> > diff --git a/target/riscv/cpu.c b/target/riscv/cpu.c
> > index 1bb3973806d2..c1d62b81a725 100644
> > --- a/target/riscv/cpu.c
> > +++ b/target/riscv/cpu.c
> > @@ -22,6 +22,7 @@
> > #include "qemu/ctype.h"
> > #include "qemu/log.h"
> > #include "cpu.h"
> > +#include "pmu.h"
> > #include "internals.h"
> > #include "exec/exec-all.h"
> > #include "qapi/error.h"
> > @@ -779,6 +780,15 @@ static void riscv_cpu_realize(DeviceState *dev,
> Error **errp)
> > set_misa(env, env->misa_mxl, ext);
> > }
> >
> > +#ifndef CONFIG_USER_ONLY
> > + if (cpu->cfg.pmu_num) {
> > + if (!riscv_pmu_init(cpu, cpu->cfg.pmu_num) &&
> cpu->cfg.ext_sscofpmf) {
> > + cpu->pmu_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
> > + riscv_pmu_timer_cb, cpu);
> > + }
> > + }
> > +#endif
> > +
> > riscv_cpu_register_gdb_regs_for_features(cs);
> >
> > qemu_init_vcpu(cs);
> > @@ -883,6 +893,7 @@ static Property riscv_cpu_extensions[] = {
> > DEFINE_PROP_BOOL("v", RISCVCPU, cfg.ext_v, false),
> > DEFINE_PROP_BOOL("h", RISCVCPU, cfg.ext_h, true),
> > DEFINE_PROP_UINT8("pmu-num", RISCVCPU, cfg.pmu_num, 16),
> > + DEFINE_PROP_BOOL("sscofpmf", RISCVCPU, cfg.ext_sscofpmf, false),
> > DEFINE_PROP_BOOL("Zifencei", RISCVCPU, cfg.ext_ifencei, true),
> > DEFINE_PROP_BOOL("Zicsr", RISCVCPU, cfg.ext_icsr, true),
> > DEFINE_PROP_BOOL("Zfh", RISCVCPU, cfg.ext_zfh, false),
> > diff --git a/target/riscv/cpu.h b/target/riscv/cpu.h
> > index 5c7acc055ac9..2222db193c3d 100644
> > --- a/target/riscv/cpu.h
> > +++ b/target/riscv/cpu.h
> > @@ -137,6 +137,8 @@ typedef struct PMUCTRState {
> > /* Snapshort value of a counter in RV32 */
> > target_ulong mhpmcounterh_prev;
> > bool started;
> > + /* Value beyond UINT32_MAX/UINT64_MAX before overflow interrupt
> trigger */
> > + target_ulong irq_overflow_left;
> > } PMUCTRState;
> >
> > struct CPUArchState {
> > @@ -297,6 +299,9 @@ struct CPUArchState {
> > /* PMU event selector configured values. First three are unused*/
> > target_ulong mhpmevent_val[RV_MAX_MHPMEVENTS];
> >
> > + /* PMU event selector configured values for RV32*/
> > + target_ulong mhpmeventh_val[RV_MAX_MHPMEVENTS];
> > +
> > target_ulong sscratch;
> > target_ulong mscratch;
> >
> > @@ -433,6 +438,7 @@ struct RISCVCPUConfig {
> > bool ext_zve32f;
> > bool ext_zve64f;
> > bool ext_zmmul;
> > + bool ext_sscofpmf;
> > bool rvv_ta_all_1s;
> >
> > uint32_t mvendorid;
> > @@ -479,6 +485,12 @@ struct ArchCPU {
> >
> > /* Configuration Settings */
> > RISCVCPUConfig cfg;
> > +
> > + QEMUTimer *pmu_timer;
> > + /* A bitmask of Available programmable counters */
> > + uint32_t pmu_avail_ctrs;
> > + /* Mapping of events to counters */
> > + GHashTable *pmu_event_ctr_map;
> > };
> >
> > static inline int riscv_has_ext(CPURISCVState *env, target_ulong ext)
> > @@ -738,6 +750,19 @@ enum {
> > CSR_TABLE_SIZE = 0x1000
> > };
> >
> > +/**
> > + * The event id are encoded based on the encoding specified in the
> > + * SBI specification v0.3
> > + */
> > +
> > +enum riscv_pmu_event_idx {
> > + RISCV_PMU_EVENT_HW_CPU_CYCLES = 0x01,
> > + RISCV_PMU_EVENT_HW_INSTRUCTIONS = 0x02,
> > + RISCV_PMU_EVENT_CACHE_DTLB_READ_MISS = 0x10019,
> > + RISCV_PMU_EVENT_CACHE_DTLB_WRITE_MISS = 0x1001B,
> > + RISCV_PMU_EVENT_CACHE_ITLB_PREFETCH_MISS = 0x10021,
> > +};
> > +
> > /* CSR function table */
> > extern riscv_csr_operations csr_ops[CSR_TABLE_SIZE];
> >
> > diff --git a/target/riscv/cpu_bits.h b/target/riscv/cpu_bits.h
> > index 6be5a9e9f046..b63c586be563 100644
> > --- a/target/riscv/cpu_bits.h
> > +++ b/target/riscv/cpu_bits.h
> > @@ -382,6 +382,37 @@
> > #define CSR_MHPMEVENT29 0x33d
> > #define CSR_MHPMEVENT30 0x33e
> > #define CSR_MHPMEVENT31 0x33f
> > +
> > +#define CSR_MHPMEVENT3H 0x723
> > +#define CSR_MHPMEVENT4H 0x724
> > +#define CSR_MHPMEVENT5H 0x725
> > +#define CSR_MHPMEVENT6H 0x726
> > +#define CSR_MHPMEVENT7H 0x727
> > +#define CSR_MHPMEVENT8H 0x728
> > +#define CSR_MHPMEVENT9H 0x729
> > +#define CSR_MHPMEVENT10H 0x72a
> > +#define CSR_MHPMEVENT11H 0x72b
> > +#define CSR_MHPMEVENT12H 0x72c
> > +#define CSR_MHPMEVENT13H 0x72d
> > +#define CSR_MHPMEVENT14H 0x72e
> > +#define CSR_MHPMEVENT15H 0x72f
> > +#define CSR_MHPMEVENT16H 0x730
> > +#define CSR_MHPMEVENT17H 0x731
> > +#define CSR_MHPMEVENT18H 0x732
> > +#define CSR_MHPMEVENT19H 0x733
> > +#define CSR_MHPMEVENT20H 0x734
> > +#define CSR_MHPMEVENT21H 0x735
> > +#define CSR_MHPMEVENT22H 0x736
> > +#define CSR_MHPMEVENT23H 0x737
> > +#define CSR_MHPMEVENT24H 0x738
> > +#define CSR_MHPMEVENT25H 0x739
> > +#define CSR_MHPMEVENT26H 0x73a
> > +#define CSR_MHPMEVENT27H 0x73b
> > +#define CSR_MHPMEVENT28H 0x73c
> > +#define CSR_MHPMEVENT29H 0x73d
> > +#define CSR_MHPMEVENT30H 0x73e
> > +#define CSR_MHPMEVENT31H 0x73f
> > +
> > #define CSR_MHPMCOUNTER3H 0xb83
> > #define CSR_MHPMCOUNTER4H 0xb84
> > #define CSR_MHPMCOUNTER5H 0xb85
> > @@ -443,6 +474,7 @@
> > #define CSR_VSMTE 0x2c0
> > #define CSR_VSPMMASK 0x2c1
> > #define CSR_VSPMBASE 0x2c2
> > +#define CSR_SCOUNTOVF 0xda0
> >
> > /* Crypto Extension */
> > #define CSR_SEED 0x015
> > @@ -620,6 +652,7 @@ typedef enum RISCVException {
> > #define IRQ_VS_EXT 10
> > #define IRQ_M_EXT 11
> > #define IRQ_S_GEXT 12
> > +#define IRQ_PMU_OVF 13
> > #define IRQ_LOCAL_MAX 16
> > #define IRQ_LOCAL_GUEST_MAX (TARGET_LONG_BITS - 1)
> >
> > @@ -637,11 +670,13 @@ typedef enum RISCVException {
> > #define MIP_VSEIP (1 << IRQ_VS_EXT)
> > #define MIP_MEIP (1 << IRQ_M_EXT)
> > #define MIP_SGEIP (1 << IRQ_S_GEXT)
> > +#define MIP_LCOFIP (1 << IRQ_PMU_OVF)
> >
> > /* sip masks */
> > #define SIP_SSIP MIP_SSIP
> > #define SIP_STIP MIP_STIP
> > #define SIP_SEIP MIP_SEIP
> > +#define SIP_LCOFIP MIP_LCOFIP
> >
> > /* MIE masks */
> > #define MIE_SEIE (1 << IRQ_S_EXT)
> > @@ -795,4 +830,24 @@ typedef enum RISCVException {
> > #define SEED_OPST_WAIT (0b01 << 30)
> > #define SEED_OPST_ES16 (0b10 << 30)
> > #define SEED_OPST_DEAD (0b11 << 30)
> > +/* PMU related bits */
> > +#define MIE_LCOFIE (1 << IRQ_PMU_OVF)
> > +
> > +#define MHPMEVENT_BIT_OF BIT_ULL(63)
> > +#define MHPMEVENTH_BIT_OF BIT(31)
> > +#define MHPMEVENT_BIT_MINH BIT_ULL(62)
> > +#define MHPMEVENTH_BIT_MINH BIT(30)
> > +#define MHPMEVENT_BIT_SINH BIT_ULL(61)
> > +#define MHPMEVENTH_BIT_SINH BIT(29)
> > +#define MHPMEVENT_BIT_UINH BIT_ULL(60)
> > +#define MHPMEVENTH_BIT_UINH BIT(28)
> > +#define MHPMEVENT_BIT_VSINH BIT_ULL(59)
> > +#define MHPMEVENTH_BIT_VSINH BIT(27)
> > +#define MHPMEVENT_BIT_VUINH BIT_ULL(58)
> > +#define MHPMEVENTH_BIT_VUINH BIT(26)
> > +
> > +#define MHPMEVENT_SSCOF_MASK _ULL(0xFFFF000000000000)
> > +#define MHPMEVENT_IDX_MASK 0xFFFFF
> > +#define MHPMEVENT_SSCOF_RESVD 16
> > +
> > #endif
> > diff --git a/target/riscv/csr.c b/target/riscv/csr.c
> > index 235f2a011e70..1233bfa0a726 100644
> > --- a/target/riscv/csr.c
> > +++ b/target/riscv/csr.c
> > @@ -74,7 +74,7 @@ static RISCVException ctr(CPURISCVState *env, int
> csrno)
> > CPUState *cs = env_cpu(env);
> > RISCVCPU *cpu = RISCV_CPU(cs);
> > int ctr_index;
> > - int base_csrno = CSR_HPMCOUNTER3;
> > + int base_csrno = CSR_CYCLE;
> > bool rv32 = riscv_cpu_mxl(env) == MXL_RV32 ? true : false;
> >
> > if (rv32 && csrno >= CSR_CYCLEH) {
> > @@ -83,11 +83,18 @@ static RISCVException ctr(CPURISCVState *env, int
> csrno)
> > }
> > ctr_index = csrno - base_csrno;
> >
> > - if (!cpu->cfg.pmu_num || ctr_index >= (cpu->cfg.pmu_num)) {
> > + if ((csrno >= CSR_CYCLE && csrno <= CSR_INSTRET) ||
> > + (csrno >= CSR_CYCLEH && csrno <= CSR_INSTRETH)) {
> > + goto skip_ext_pmu_check;
> > + }
> > +
> > + if ((!cpu->cfg.pmu_num || !(cpu->pmu_avail_ctrs & BIT(ctr_index))))
> {
> > /* No counter is enabled in PMU or the counter is out of range
> */
> > return RISCV_EXCP_ILLEGAL_INST;
> > }
> >
> Maybe it's better to remove !cpu->cfg.pmu_num here, not in later commit.
> > +skip_ext_pmu_check:
> > +
> > if (env->priv == PRV_S) {
> > switch (csrno) {
> > case CSR_CYCLE:
> > @@ -106,7 +113,6 @@ static RISCVException ctr(CPURISCVState *env, int
> csrno)
> > }
> > break;
> > case CSR_HPMCOUNTER3...CSR_HPMCOUNTER31:
> > - ctr_index = csrno - CSR_CYCLE;
> > if (!get_field(env->mcounteren, 1 << ctr_index)) {
> > return RISCV_EXCP_ILLEGAL_INST;
> > }
> > @@ -130,7 +136,6 @@ static RISCVException ctr(CPURISCVState *env, int
> csrno)
> > }
> > break;
> > case CSR_HPMCOUNTER3H...CSR_HPMCOUNTER31H:
> > - ctr_index = csrno - CSR_CYCLEH;
> > if (!get_field(env->mcounteren, 1 << ctr_index)) {
> > return RISCV_EXCP_ILLEGAL_INST;
> > }
> > @@ -160,7 +165,6 @@ static RISCVException ctr(CPURISCVState *env, int
> csrno)
> > }
> > break;
> > case CSR_HPMCOUNTER3...CSR_HPMCOUNTER31:
> > - ctr_index = csrno - CSR_CYCLE;
> > if (!get_field(env->hcounteren, 1 << ctr_index) &&
> > get_field(env->mcounteren, 1 << ctr_index)) {
> > return RISCV_EXCP_VIRT_INSTRUCTION_FAULT;
> > @@ -188,7 +192,6 @@ static RISCVException ctr(CPURISCVState *env, int
> csrno)
> > }
> > break;
> > case CSR_HPMCOUNTER3H...CSR_HPMCOUNTER31H:
> > - ctr_index = csrno - CSR_CYCLEH;
> > if (!get_field(env->hcounteren, 1 << ctr_index) &&
> > get_field(env->mcounteren, 1 << ctr_index)) {
> > return RISCV_EXCP_VIRT_INSTRUCTION_FAULT;
> > @@ -240,6 +243,18 @@ static RISCVException mctr32(CPURISCVState *env,
> int csrno)
> > return mctr(env, csrno);
> > }
> >
> > +static RISCVException sscofpmf(CPURISCVState *env, int csrno)
> > +{
> > + CPUState *cs = env_cpu(env);
> > + RISCVCPU *cpu = RISCV_CPU(cs);
> > +
> > + if (!cpu->cfg.ext_sscofpmf) {
> > + return RISCV_EXCP_ILLEGAL_INST;
> > + }
> > +
> > + return RISCV_EXCP_NONE;
> > +}
> > +
> > static RISCVException any(CPURISCVState *env, int csrno)
> > {
> > return RISCV_EXCP_NONE;
> > @@ -663,9 +678,39 @@ static int read_mhpmevent(CPURISCVState *env, int
> csrno, target_ulong *val)
> > static int write_mhpmevent(CPURISCVState *env, int csrno, target_ulong
> val)
> > {
> > int evt_index = csrno - CSR_MCOUNTINHIBIT;
> > + uint64_t mhpmevt_val = val;
> >
> > env->mhpmevent_val[evt_index] = val;
> >
> > + if (riscv_cpu_mxl(env) == MXL_RV32) {
> > + mhpmevt_val = mhpmevt_val |
> > + ((uint64_t)env->mhpmeventh_val[evt_index] << 32);
> > + }
> > + riscv_pmu_update_event_map(env, mhpmevt_val, evt_index);
> > +
> > + return RISCV_EXCP_NONE;
> > +}
> > +
> > +static int read_mhpmeventh(CPURISCVState *env, int csrno, target_ulong
> *val)
> > +{
> > + int evt_index = csrno - CSR_MHPMEVENT3H + 3;
> > +
> > + *val = env->mhpmeventh_val[evt_index];
> > +
> > + return RISCV_EXCP_NONE;
> > +}
> > +
> > +static int write_mhpmeventh(CPURISCVState *env, int csrno, target_ulong
> val)
> > +{
> > + int evt_index = csrno - CSR_MHPMEVENT3H + 3;
> > + uint64_t mhpmevth_val = val;
> > + uint64_t mhpmevt_val = env->mhpmevent_val[evt_index];
> > +
> > + mhpmevt_val = mhpmevt_val | (mhpmevth_val << 32);
> > + env->mhpmeventh_val[evt_index] = val;
> > +
> > + riscv_pmu_update_event_map(env, mhpmevt_val, evt_index);
> > +
> > return RISCV_EXCP_NONE;
> > }
> >
> > @@ -673,12 +718,20 @@ static int write_mhpmcounter(CPURISCVState *env,
> int csrno, target_ulong val)
> > {
> > int ctr_idx = csrno - CSR_MCYCLE;
> > PMUCTRState *counter = &env->pmu_ctrs[ctr_idx];
> > + uint64_t mhpmctr_val = val;
> >
> > counter->mhpmcounter_val = val;
> > if (riscv_pmu_ctr_monitor_cycles(env, ctr_idx) ||
> > riscv_pmu_ctr_monitor_instructions(env, ctr_idx)) {
> > counter->mhpmcounter_prev = get_ticks(false);
> > - } else {
> > + if (ctr_idx > 2) {
> > + if (riscv_cpu_mxl(env) == MXL_RV32) {
> > + mhpmctr_val = mhpmctr_val |
> > + ((uint64_t)counter->mhpmcounterh_val <<
> 32);
> > + }
> > + riscv_pmu_setup_timer(env, mhpmctr_val, ctr_idx);
> > + }
> > + } else {
> > /* Other counters can keep incrementing from the given value */
> > counter->mhpmcounter_prev = val;
> > }
> > @@ -690,11 +743,17 @@ static int write_mhpmcounterh(CPURISCVState *env,
> int csrno, target_ulong val)
> > {
> > int ctr_idx = csrno - CSR_MCYCLEH;
> > PMUCTRState *counter = &env->pmu_ctrs[ctr_idx];
> > + uint64_t mhpmctr_val = counter->mhpmcounter_val;
> > + uint64_t mhpmctrh_val = val;
> >
> > counter->mhpmcounterh_val = val;
> > + mhpmctr_val = mhpmctr_val | (mhpmctrh_val << 32);
> > if (riscv_pmu_ctr_monitor_cycles(env, ctr_idx) ||
> > riscv_pmu_ctr_monitor_instructions(env, ctr_idx)) {
> > counter->mhpmcounterh_prev = get_ticks(true);
> > + if (ctr_idx > 2) {
> > + riscv_pmu_setup_timer(env, mhpmctr_val, ctr_idx);
> > + }
> > } else {
> > counter->mhpmcounterh_prev = val;
> > }
> > @@ -770,6 +829,32 @@ static int read_hpmcounterh(CPURISCVState *env, int
> csrno, target_ulong *val)
> > return riscv_pmu_read_ctr(env, val, true, ctr_index);
> > }
> >
> > +static int read_scountovf(CPURISCVState *env, int csrno, target_ulong
> *val)
> > +{
> > + int mhpmevt_start = CSR_MHPMEVENT3 - CSR_MCOUNTINHIBIT;
> > + int i;
> > + *val = 0;
> > + target_ulong *mhpm_evt_val;
> > + uint64_t of_bit_mask;
> > +
> > + if (riscv_cpu_mxl(env) == MXL_RV32) {
> > + mhpm_evt_val = env->mhpmeventh_val;
> > + of_bit_mask = MHPMEVENTH_BIT_OF;
> > + } else {
> > + mhpm_evt_val = env->mhpmevent_val;
> > + of_bit_mask = MHPMEVENT_BIT_OF;
> > + }
> > +
> > + for (i = mhpmevt_start; i < RV_MAX_MHPMEVENTS; i++) {
> > + if ((get_field(env->mcounteren, BIT(i))) &&
> > + (mhpm_evt_val[i] & of_bit_mask)) {
> > + *val |= BIT(i);
> > + }
> > + }
> > +
> > + return RISCV_EXCP_NONE;
> > +}
> > +
> > static RISCVException read_time(CPURISCVState *env, int csrno,
> > target_ulong *val)
> > {
> > @@ -799,7 +884,8 @@ static RISCVException read_timeh(CPURISCVState *env,
> int csrno,
> > /* Machine constants */
> >
> > #define M_MODE_INTERRUPTS ((uint64_t)(MIP_MSIP | MIP_MTIP | MIP_MEIP))
> > -#define S_MODE_INTERRUPTS ((uint64_t)(MIP_SSIP | MIP_STIP | MIP_SEIP))
> > +#define S_MODE_INTERRUPTS ((uint64_t)(MIP_SSIP | MIP_STIP | MIP_SEIP |
> \
> > + MIP_LCOFIP))
>
> It's better to align with MIP_SSIP here.
>
> > #define VS_MODE_INTERRUPTS ((uint64_t)(MIP_VSSIP | MIP_VSTIP |
> MIP_VSEIP))
> > #define HS_MODE_INTERRUPTS ((uint64_t)(MIP_SGEIP | VS_MODE_INTERRUPTS))
> >
> > @@ -840,7 +926,8 @@ static const target_ulong vs_delegable_excps =
> DELEGABLE_EXCPS &
> > static const target_ulong sstatus_v1_10_mask = SSTATUS_SIE |
> SSTATUS_SPIE |
> > SSTATUS_UIE | SSTATUS_UPIE | SSTATUS_SPP | SSTATUS_FS | SSTATUS_XS
> |
> > SSTATUS_SUM | SSTATUS_MXR | SSTATUS_VS;
> > -static const target_ulong sip_writable_mask = SIP_SSIP | MIP_USIP |
> MIP_UEIP;
> > +static const target_ulong sip_writable_mask = SIP_SSIP | MIP_USIP |
> MIP_UEIP |
> > + SIP_LCOFIP;
> > static const target_ulong hip_writable_mask = MIP_VSSIP;
> > static const target_ulong hvip_writable_mask = MIP_VSSIP | MIP_VSTIP |
> MIP_VSEIP;
> > static const target_ulong vsip_writable_mask = MIP_VSSIP;
> > @@ -3861,6 +3948,65 @@ riscv_csr_operations csr_ops[CSR_TABLE_SIZE] = {
> > [CSR_MHPMEVENT31] = { "mhpmevent31", any, read_mhpmevent,
> > write_mhpmevent
> },
> >
> > + [CSR_MHPMEVENT3H] = { "mhpmevent3h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
>
> The new lines have been updated to align with the last line in my
> previous patchset(accepted).
>
> you can see it if rebase to riscv-to-apply.next. So it's better to make
> write_mhpmeventh align with
>
> ' " '. The same to following new lines.
>
>
Got it. Rebased it. But I aligned them '{' with CSR_HPMCOUNTER3H onwards.
We probably should align CSR_MHPMEVENT3..CSR_MHPMEVENT31 accordingly as
well.
> Regards,
>
> Weiwei Li
>
> > + [CSR_MHPMEVENT4H] = { "mhpmevent4h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT5H] = { "mhpmevent5h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT6H] = { "mhpmevent6h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT7H] = { "mhpmevent7h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT8H] = { "mhpmevent8h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT9H] = { "mhpmevent9h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT10H] = { "mhpmevent10h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT11H] = { "mhpmevent11h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT12H] = { "mhpmevent12h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT13H] = { "mhpmevent13h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT14H] = { "mhpmevent14h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT15H] = { "mhpmevent15h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT16H] = { "mhpmevent16h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT17H] = { "mhpmevent17h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT18H] = { "mhpmevent18h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT19H] = { "mhpmevent19h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT20H] = { "mhpmevent20h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT21H] = { "mhpmevent21h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT22H] = { "mhpmevent22h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT23H] = { "mhpmevent23h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT24H] = { "mhpmevent24h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT25H] = { "mhpmevent25h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT26H] = { "mhpmevent26h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT27H] = { "mhpmevent27h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT28H] = { "mhpmevent28h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT29H] = { "mhpmevent29h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT30H] = { "mhpmevent30h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > + [CSR_MHPMEVENT31H] = { "mhpmevent31h", sscofpmf,
> read_mhpmeventh,
> > +
> write_mhpmeventh},
> > +
> > [CSR_HPMCOUNTER3H] = { "hpmcounter3h", ctr32,
> read_hpmcounterh },
> > [CSR_HPMCOUNTER4H] = { "hpmcounter4h", ctr32,
> read_hpmcounterh },
> > [CSR_HPMCOUNTER5H] = { "hpmcounter5h", ctr32,
> read_hpmcounterh },
> > @@ -3949,5 +4095,7 @@ riscv_csr_operations csr_ops[CSR_TABLE_SIZE] = {
> >
> write_mhpmcounterh },
> > [CSR_MHPMCOUNTER31H] = { "mhpmcounter31h", mctr32,
> read_hpmcounterh,
> >
> write_mhpmcounterh },
> > + [CSR_SCOUNTOVF] = { "scountovf", sscofpmf, read_scountovf },
> > +
> > #endif /* !CONFIG_USER_ONLY */
> > };
> > diff --git a/target/riscv/machine.c b/target/riscv/machine.c
> > index dc182ca81119..33ef9b8e9908 100644
> > --- a/target/riscv/machine.c
> > +++ b/target/riscv/machine.c
> > @@ -355,6 +355,7 @@ const VMStateDescription vmstate_riscv_cpu = {
> > VMSTATE_STRUCT_ARRAY(env.pmu_ctrs, RISCVCPU,
> RV_MAX_MHPMCOUNTERS, 0,
> > vmstate_pmu_ctr_state, PMUCTRState),
> > VMSTATE_UINTTL_ARRAY(env.mhpmevent_val, RISCVCPU,
> RV_MAX_MHPMEVENTS),
> > + VMSTATE_UINTTL_ARRAY(env.mhpmeventh_val, RISCVCPU,
> RV_MAX_MHPMEVENTS),
> > VMSTATE_UINTTL(env.sscratch, RISCVCPU),
> > VMSTATE_UINTTL(env.mscratch, RISCVCPU),
> > VMSTATE_UINT64(env.mfromhost, RISCVCPU),
> > diff --git a/target/riscv/pmu.c b/target/riscv/pmu.c
> > index 000fe8da45ef..34096941c0ce 100644
> > --- a/target/riscv/pmu.c
> > +++ b/target/riscv/pmu.c
> > @@ -19,14 +19,367 @@
> > #include "qemu/osdep.h"
> > #include "cpu.h"
> > #include "pmu.h"
> > +#include "sysemu/cpu-timers.h"
> > +
> > +#define RISCV_TIMEBASE_FREQ 1000000000 /* 1Ghz */
> > +#define MAKE_32BIT_MASK(shift, length) \
> > + (((uint32_t)(~0UL) >> (32 - (length))) << (shift))
> > +
> > +static bool riscv_pmu_counter_valid(RISCVCPU *cpu, uint32_t ctr_idx)
> > +{
> > + if (ctr_idx < 3 || ctr_idx >= RV_MAX_MHPMCOUNTERS ||
> > + !(cpu->pmu_avail_ctrs & BIT(ctr_idx))) {
> > + return false;
> > + } else {
> > + return true;
> > + }
> > +}
> > +
> > +static bool riscv_pmu_counter_enabled(RISCVCPU *cpu, uint32_t ctr_idx)
> > +{
> > + CPURISCVState *env = &cpu->env;
> > +
> > + if (riscv_pmu_counter_valid(cpu, ctr_idx) &&
> > + !get_field(env->mcountinhibit, BIT(ctr_idx))) {
> > + return true;
> > + } else {
> > + return false;
> > + }
> > +}
> > +
> > +static int riscv_pmu_incr_ctr_rv32(RISCVCPU *cpu, uint32_t ctr_idx)
> > +{
> > + CPURISCVState *env = &cpu->env;
> > + target_ulong max_val = UINT32_MAX;
> > + PMUCTRState *counter = &env->pmu_ctrs[ctr_idx];
> > + bool virt_on = riscv_cpu_virt_enabled(env);
> > +
> > + /* Privilege mode filtering */
> > + if ((env->priv == PRV_M &&
> > + (env->mhpmeventh_val[ctr_idx] & MHPMEVENTH_BIT_MINH)) ||
> > + (env->priv == PRV_S && virt_on &&
> > + (env->mhpmeventh_val[ctr_idx] & MHPMEVENTH_BIT_VSINH)) ||
> > + (env->priv == PRV_U && virt_on &&
> > + (env->mhpmeventh_val[ctr_idx] & MHPMEVENTH_BIT_VUINH)) ||
> > + (env->priv == PRV_S && !virt_on &&
> > + (env->mhpmeventh_val[ctr_idx] & MHPMEVENTH_BIT_SINH)) ||
> > + (env->priv == PRV_U && !virt_on &&
> > + (env->mhpmeventh_val[ctr_idx] & MHPMEVENTH_BIT_UINH))) {
> > + return 0;
> > + }
> > +
> > + /* Handle the overflow scenario */
> > + if (counter->mhpmcounter_val == max_val) {
> > + if (counter->mhpmcounterh_val == max_val) {
> > + counter->mhpmcounter_val = 0;
> > + counter->mhpmcounterh_val = 0;
> > + /* Generate interrupt only if OF bit is clear */
> > + if (!(env->mhpmeventh_val[ctr_idx] & MHPMEVENTH_BIT_OF)) {
> > + env->mhpmeventh_val[ctr_idx] |= MHPMEVENTH_BIT_OF;
> > + riscv_cpu_update_mip(cpu, MIP_LCOFIP, BOOL_TO_MASK(1));
> > + }
> > + } else {
> > + counter->mhpmcounterh_val++;
> > + }
> > + } else {
> > + counter->mhpmcounter_val++;
> > + }
> > +
> > + return 0;
> > +}
> > +
> > +static int riscv_pmu_incr_ctr_rv64(RISCVCPU *cpu, uint32_t ctr_idx)
> > +{
> > + CPURISCVState *env = &cpu->env;
> > + PMUCTRState *counter = &env->pmu_ctrs[ctr_idx];
> > + uint64_t max_val = UINT64_MAX;
> > + bool virt_on = riscv_cpu_virt_enabled(env);
> > +
> > + /* Privilege mode filtering */
> > + if ((env->priv == PRV_M &&
> > + (env->mhpmevent_val[ctr_idx] & MHPMEVENT_BIT_MINH)) ||
> > + (env->priv == PRV_S && virt_on &&
> > + (env->mhpmevent_val[ctr_idx] & MHPMEVENT_BIT_VSINH)) ||
> > + (env->priv == PRV_U && virt_on &&
> > + (env->mhpmevent_val[ctr_idx] & MHPMEVENT_BIT_VUINH)) ||
> > + (env->priv == PRV_S && !virt_on &&
> > + (env->mhpmevent_val[ctr_idx] & MHPMEVENT_BIT_SINH)) ||
> > + (env->priv == PRV_U && !virt_on &&
> > + (env->mhpmevent_val[ctr_idx] & MHPMEVENT_BIT_UINH))) {
> > + return 0;
> > + }
> > +
> > + /* Handle the overflow scenario */
> > + if (counter->mhpmcounter_val == max_val) {
> > + counter->mhpmcounter_val = 0;
> > + /* Generate interrupt only if OF bit is clear */
> > + if (!(env->mhpmevent_val[ctr_idx] & MHPMEVENT_BIT_OF)) {
> > + env->mhpmevent_val[ctr_idx] |= MHPMEVENT_BIT_OF;
> > + riscv_cpu_update_mip(cpu, MIP_LCOFIP, BOOL_TO_MASK(1));
> > + }
> > + } else {
> > + counter->mhpmcounter_val++;
> > + }
> > + return 0;
> > +}
> > +
> > +int riscv_pmu_incr_ctr(RISCVCPU *cpu, enum riscv_pmu_event_idx
> event_idx)
> > +{
> > + uint32_t ctr_idx;
> > + int ret;
> > + CPURISCVState *env = &cpu->env;
> > + gpointer value;
> > +
> > + value = g_hash_table_lookup(cpu->pmu_event_ctr_map,
> > + GUINT_TO_POINTER(event_idx));
> > + if (!value) {
> > + return -1;
> > + }
> > +
> > + ctr_idx = GPOINTER_TO_UINT(value);
> > + if (!riscv_pmu_counter_enabled(cpu, ctr_idx) ||
> > + get_field(env->mcountinhibit, BIT(ctr_idx))) {
> > + return -1;
> > + }
> > +
> > + if (riscv_cpu_mxl(env) == MXL_RV32) {
> > + ret = riscv_pmu_incr_ctr_rv32(cpu, ctr_idx);
> > + } else {
> > + ret = riscv_pmu_incr_ctr_rv64(cpu, ctr_idx);
> > + }
> > +
> > + return ret;
> > +}
> >
> > bool riscv_pmu_ctr_monitor_instructions(CPURISCVState *env,
> > uint32_t target_ctr)
> > {
> > - return (target_ctr == 0) ? true : false;
> > + RISCVCPU *cpu;
> > + uint32_t event_idx;
> > + uint32_t ctr_idx;
> > +
> > + /* Fixed instret counter */
> > + if (target_ctr == 2) {
> > + return true;
> > + }
> > +
> > + cpu = RISCV_CPU(env_cpu(env));
> > + event_idx = RISCV_PMU_EVENT_HW_INSTRUCTIONS;
> > + ctr_idx =
> GPOINTER_TO_UINT(g_hash_table_lookup(cpu->pmu_event_ctr_map,
> > + GUINT_TO_POINTER(event_idx)));
> > + if (!ctr_idx) {
> > + return false;
> > + }
> > +
> > + return target_ctr == ctr_idx ? true : false;
> > }
> >
> > bool riscv_pmu_ctr_monitor_cycles(CPURISCVState *env, uint32_t
> target_ctr)
> > {
> > - return (target_ctr == 2) ? true : false;
> > + RISCVCPU *cpu;
> > + uint32_t event_idx;
> > + uint32_t ctr_idx;
> > +
> > + /* Fixed mcycle counter */
> > + if (target_ctr == 0) {
> > + return true;
> > + }
> > +
> > + cpu = RISCV_CPU(env_cpu(env));
> > + event_idx = RISCV_PMU_EVENT_HW_CPU_CYCLES;
> > + ctr_idx =
> GPOINTER_TO_UINT(g_hash_table_lookup(cpu->pmu_event_ctr_map,
> > + GUINT_TO_POINTER(event_idx)));
> > +
> > + /* Counter zero is not used for event_ctr_map */
> > + if (!ctr_idx) {
> > + return false;
> > + }
> > +
> > + return (target_ctr == ctr_idx) ? true : false;
> > +}
> > +
> > +static gboolean pmu_remove_event_map(gpointer key, gpointer value,
> > + gpointer udata)
> > +{
> > + return (GPOINTER_TO_UINT(value) == GPOINTER_TO_UINT(udata)) ? true
> : false;
> > +}
> > +
> > +static int64_t pmu_icount_ticks_to_ns(int64_t value)
> > +{
> > + int64_t ret = 0;
> > +
> > + if (icount_enabled()) {
> > + ret = icount_to_ns(value);
> > + } else {
> > + ret = (NANOSECONDS_PER_SECOND / RISCV_TIMEBASE_FREQ) * value;
> > + }
> > +
> > + return ret;
> > +}
> > +
> > +int riscv_pmu_update_event_map(CPURISCVState *env, uint64_t value,
> > + uint32_t ctr_idx)
> > +{
> > + uint32_t event_idx;
> > + RISCVCPU *cpu = RISCV_CPU(env_cpu(env));
> > +
> > + if (!riscv_pmu_counter_valid(cpu, ctr_idx)) {
> > + return -1;
> > + }
> > +
> > + /**
> > + * Expected mhpmevent value is zero for reset case. Remove the
> current
> > + * mapping.
> > + */
> > + if (!value) {
> > + g_hash_table_foreach_remove(cpu->pmu_event_ctr_map,
> > + pmu_remove_event_map,
> > + GUINT_TO_POINTER(ctr_idx));
> > + return 0;
> > + }
> > +
> > + event_idx = value & MHPMEVENT_IDX_MASK;
> > + if (g_hash_table_lookup(cpu->pmu_event_ctr_map,
> > + GUINT_TO_POINTER(event_idx))) {
> > + return 0;
> > + }
> > +
> > + switch (event_idx) {
> > + case RISCV_PMU_EVENT_HW_CPU_CYCLES:
> > + case RISCV_PMU_EVENT_HW_INSTRUCTIONS:
> > + case RISCV_PMU_EVENT_CACHE_DTLB_READ_MISS:
> > + case RISCV_PMU_EVENT_CACHE_DTLB_WRITE_MISS:
> > + case RISCV_PMU_EVENT_CACHE_ITLB_PREFETCH_MISS:
> > + break;
> > + default:
> > + /* We don't support any raw events right now */
> > + return -1;
> > + }
> > + g_hash_table_insert(cpu->pmu_event_ctr_map,
> GUINT_TO_POINTER(event_idx),
> > + GUINT_TO_POINTER(ctr_idx));
> > +
> > + return 0;
> > +}
> > +
> > +static void pmu_timer_trigger_irq(RISCVCPU *cpu,
> > + enum riscv_pmu_event_idx evt_idx)
> > +{
> > + uint32_t ctr_idx;
> > + CPURISCVState *env = &cpu->env;
> > + PMUCTRState *counter;
> > + target_ulong *mhpmevent_val;
> > + uint64_t of_bit_mask;
> > + int64_t irq_trigger_at;
> > +
> > + if (evt_idx != RISCV_PMU_EVENT_HW_CPU_CYCLES &&
> > + evt_idx != RISCV_PMU_EVENT_HW_INSTRUCTIONS) {
> > + return;
> > + }
> > +
> > + ctr_idx =
> GPOINTER_TO_UINT(g_hash_table_lookup(cpu->pmu_event_ctr_map,
> > + GUINT_TO_POINTER(evt_idx)));
> > + if (!riscv_pmu_counter_enabled(cpu, ctr_idx)) {
> > + return;
> > + }
> > +
> > + if (riscv_cpu_mxl(env) == MXL_RV32) {
> > + mhpmevent_val = &env->mhpmeventh_val[ctr_idx];
> > + of_bit_mask = MHPMEVENTH_BIT_OF;
> > + } else {
> > + mhpmevent_val = &env->mhpmevent_val[ctr_idx];
> > + of_bit_mask = MHPMEVENT_BIT_OF;
> > + }
> > +
> > + counter = &env->pmu_ctrs[ctr_idx];
> > + if (counter->irq_overflow_left > 0) {
> > + irq_trigger_at = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
> > + counter->irq_overflow_left;
> > + timer_mod_anticipate_ns(cpu->pmu_timer, irq_trigger_at);
> > + counter->irq_overflow_left = 0;
> > + return;
> > + }
> > +
> > + if (cpu->pmu_avail_ctrs & BIT(ctr_idx)) {
> > + /* Generate interrupt only if OF bit is clear */
> > + if (!(*mhpmevent_val & of_bit_mask)) {
> > + *mhpmevent_val |= of_bit_mask;
> > + riscv_cpu_update_mip(cpu, MIP_LCOFIP, BOOL_TO_MASK(1));
> > + }
> > + }
> > +}
> > +
> > +/* Timer callback for instret and cycle counter overflow */
> > +void riscv_pmu_timer_cb(void *priv)
> > +{
> > + RISCVCPU *cpu = priv;
> > +
> > + /* Timer event was triggered only for these events */
> > + pmu_timer_trigger_irq(cpu, RISCV_PMU_EVENT_HW_CPU_CYCLES);
> > + pmu_timer_trigger_irq(cpu, RISCV_PMU_EVENT_HW_INSTRUCTIONS);
> > +}
> > +
> > +int riscv_pmu_setup_timer(CPURISCVState *env, uint64_t value, uint32_t
> ctr_idx)
> > +{
> > + uint64_t overflow_delta, overflow_at;
> > + int64_t overflow_ns, overflow_left = 0;
> > + RISCVCPU *cpu = RISCV_CPU(env_cpu(env));
> > + PMUCTRState *counter = &env->pmu_ctrs[ctr_idx];
> > +
> > + if (!riscv_pmu_counter_valid(cpu, ctr_idx) ||
> !cpu->cfg.ext_sscofpmf) {
> > + return -1;
> > + }
> > +
> > + if (value) {
> > + overflow_delta = UINT64_MAX - value + 1;
> > + } else {
> > + overflow_delta = UINT64_MAX;
> > + }
> > +
> > + /**
> > + * QEMU supports only int64_t timers while RISC-V counters are
> uint64_t.
> > + * Compute the leftover and save it so that it can be reprogrammed
> again
> > + * when timer expires.
> > + */
> > + if (overflow_delta > INT64_MAX) {
> > + overflow_left = overflow_delta - INT64_MAX;
> > + }
> > +
> > + if (riscv_pmu_ctr_monitor_cycles(env, ctr_idx) ||
> > + riscv_pmu_ctr_monitor_instructions(env, ctr_idx)) {
> > + overflow_ns = pmu_icount_ticks_to_ns((int64_t)overflow_delta);
> > + overflow_left = pmu_icount_ticks_to_ns(overflow_left) ;
> > + } else {
> > + return -1;
> > + }
> > + overflow_at = (uint64_t)qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
> overflow_ns;
> > +
> > + if (overflow_at > INT64_MAX) {
> > + overflow_left += overflow_at - INT64_MAX;
> > + counter->irq_overflow_left = overflow_left;
> > + overflow_at = INT64_MAX;
> > + }
> > + timer_mod_anticipate_ns(cpu->pmu_timer, overflow_at);
> > +
> > + return 0;
> > +}
> > +
> > +
> > +int riscv_pmu_init(RISCVCPU *cpu, int num_counters)
> > +{
> > + if (num_counters > (RV_MAX_MHPMCOUNTERS - 3)) {
> > + return -1;
> > + }
> > +
> > + cpu->pmu_event_ctr_map = g_hash_table_new(g_direct_hash,
> g_direct_equal);
> > + if (!cpu->pmu_event_ctr_map) {
> > + /* PMU support can not be enabled */
> > + qemu_log_mask(LOG_UNIMP, "PMU events can't be supported\n");
> > + cpu->cfg.pmu_num = 0;
> > + return -1;
> > + }
> > +
> > + /* Create a bitmask of available programmable counters */
> > + cpu->pmu_avail_ctrs = MAKE_32BIT_MASK(3, num_counters);
> > +
> > + return 0;
> > }
> > diff --git a/target/riscv/pmu.h b/target/riscv/pmu.h
> > index 58a5bc3a4089..036653627f78 100644
> > --- a/target/riscv/pmu.h
> > +++ b/target/riscv/pmu.h
> > @@ -26,3 +26,10 @@ bool riscv_pmu_ctr_monitor_instructions(CPURISCVState
> *env,
> > uint32_t target_ctr);
> > bool riscv_pmu_ctr_monitor_cycles(CPURISCVState *env,
> > uint32_t target_ctr);
> > +void riscv_pmu_timer_cb(void *priv);
> > +int riscv_pmu_init(RISCVCPU *cpu, int num_counters);
> > +int riscv_pmu_update_event_map(CPURISCVState *env, uint64_t value,
> > + uint32_t ctr_idx);
> > +int riscv_pmu_incr_ctr(RISCVCPU *cpu, enum riscv_pmu_event_idx
> event_idx);
> > +int riscv_pmu_setup_timer(CPURISCVState *env, uint64_t value,
> > + uint32_t ctr_idx);
>
>
