Allow platform to handle load/store faults

This simplifies both handlers such that when the handler needs to redirect the original trap, it's readily available.

Signed-off-by Bo Gan <[email protected]>

---
 include/sbi/sbi_trap_ldst.h |  9 ++++----
 lib/sbi/sbi_trap.c          | 21 ++++++++++---------
 lib/sbi/sbi_trap_ldst.c     | 50 +++++++++++++++++----------------------------
 3 files changed, 35 insertions(+), 45 deletions(-)

include/sbi/sbi_trap_ldst.h +5 -4

index 9bbd237..5f0ed92 100644
@@ -11,13 +11,14 @@
 #define __SBI_TRAP_LDST_H__
 
 #include <sbi/sbi_types.h>
+#include <sbi/sbi_trap.h>
 
 struct sbi_trap_regs;
 
-int sbi_misaligned_load_handler(ulong addr, ulong tval2, ulong tinst,
-                               struct sbi_trap_regs *regs);
+int sbi_misaligned_load_handler(struct sbi_trap_regs *regs,
+                               const struct sbi_trap_info *orig_trap);
 
-int sbi_misaligned_store_handler(ulong addr, ulong tval2, ulong tinst,
-                                struct sbi_trap_regs *regs);
+int sbi_misaligned_store_handler(struct sbi_trap_regs *regs,
+                                const struct sbi_trap_info *orig_trap);
 
 #endif

lib/sbi/sbi_trap.c +11 -10

index 1024981..e379984 100644
@@ -285,6 +285,13 @@ struct sbi_trap_regs *sbi_trap_handler(struct sbi_trap_regs *regs)
                }
                return regs;
        }
+       /* Original trap_info */
+       trap.epc   = regs->mepc;
+       trap.cause = mcause;
+       trap.tval  = mtval;
+       trap.tval2 = mtval2;
+       trap.tinst = mtinst;
+       trap.gva   = sbi_regs_gva(regs);
 
        switch (mcause) {
        case CAUSE_ILLEGAL_INSTRUCTION:

@@ -292,11 +299,11 @@ struct sbi_trap_regs *sbi_trap_handler(struct sbi_trap_regs *regs)
                msg = "illegal instruction handler failed";
                break;
        case CAUSE_MISALIGNED_LOAD:
-               rc = sbi_misaligned_load_handler(mtval, mtval2, mtinst, regs);
+               rc  = sbi_misaligned_load_handler(regs, &trap);
                msg = "misaligned load handler failed";
                break;
        case CAUSE_MISALIGNED_STORE:
-               rc  = sbi_misaligned_store_handler(mtval, mtval2, mtinst, regs);
+               rc  = sbi_misaligned_store_handler(regs, &trap);
                msg = "misaligned store handler failed";
                break;
        case CAUSE_SUPERVISOR_ECALL:

@@ -311,14 +318,8 @@ struct sbi_trap_regs *sbi_trap_handler(struct sbi_trap_regs *regs)
                /* fallthrough */
        default:
                /* If the trap came from S or U mode, redirect it there */
-               trap.epc = regs->mepc;
-               trap.cause = mcause;
-               trap.tval = mtval;
-               trap.tval2 = mtval2;
-               trap.tinst = mtinst;
-               trap.gva   = sbi_regs_gva(regs);
-
-               rc = sbi_trap_redirect(regs, &trap);
+               msg = "trap redirect failed";
+               rc  = sbi_trap_redirect(regs, &trap);
                break;
        }
 

lib/sbi/sbi_trap_ldst.c +19 -32

index be9a394..1fb0ed6 100644
@@ -34,8 +34,8 @@ static ulong sbi_misaligned_tinst_fixup(ulong orig_tinst, ulong new_tinst,
                return orig_tinst | (addr_offset << SH_RS1);
 }
 
-int sbi_misaligned_load_handler(ulong addr, ulong tval2, ulong tinst,
-                               struct sbi_trap_regs *regs)
+int sbi_misaligned_load_handler(struct sbi_trap_regs *regs,
+                               const struct sbi_trap_info *orig_trap)
 {
        ulong insn, insn_len;
        union reg_data val;

@@ -44,13 +44,13 @@ int sbi_misaligned_load_handler(ulong addr, ulong tval2, ulong tinst,
 
        sbi_pmu_ctr_incr_fw(SBI_PMU_FW_MISALIGNED_LOAD);
 
-       if (tinst & 0x1) {
+       if (orig_trap->tinst & 0x1) {
                /*
                 * Bit[0] == 1 implies trapped instruction value is
                 * transformed instruction or custom instruction.
                 */
-               insn = tinst | INSN_16BIT_MASK;
-               insn_len = (tinst & 0x2) ? INSN_LEN(insn) : 2;
+               insn     = orig_trap->tinst | INSN_16BIT_MASK;
+               insn_len = (orig_trap->tinst & 0x2) ? INSN_LEN(insn) : 2;
        } else {
                /*
                 * Bit[0] == 0 implies trapped instruction value is

@@ -124,23 +124,17 @@ int sbi_misaligned_load_handler(ulong addr, ulong tval2, ulong tinst,
 #endif
 #endif
        } else {
-               uptrap.epc = regs->mepc;
-               uptrap.cause = CAUSE_MISALIGNED_LOAD;
-               uptrap.tval = addr;
-               uptrap.tval2 = tval2;
-               uptrap.tinst = tinst;
-               uptrap.gva   = sbi_regs_gva(regs);
-               return sbi_trap_redirect(regs, &uptrap);
+               return sbi_trap_redirect(regs, orig_trap);
        }
 
        val.data_u64 = 0;
        for (i = 0; i < len; i++) {
-               val.data_bytes[i] = sbi_load_u8((void *)(addr + i),
-                                               &uptrap);
+               val.data_bytes[i] =
+                       sbi_load_u8((void *)(orig_trap->tval + i), &uptrap);
                if (uptrap.cause) {
-                       uptrap.epc = regs->mepc;
+                       uptrap.epc   = regs->mepc;
                        uptrap.tinst = sbi_misaligned_tinst_fixup(
-                               tinst, uptrap.tinst, i);
+                               orig_trap->tinst, uptrap.tinst, i);
                        return sbi_trap_redirect(regs, &uptrap);
                }
        }

@@ -159,8 +153,8 @@ int sbi_misaligned_load_handler(ulong addr, ulong tval2, ulong tinst,
        return 0;
 }
 
-int sbi_misaligned_store_handler(ulong addr, ulong tval2, ulong tinst,
-                                struct sbi_trap_regs *regs)
+int sbi_misaligned_store_handler(struct sbi_trap_regs *regs,
+                                const struct sbi_trap_info *orig_trap)
 {
        ulong insn, insn_len;
        union reg_data val;

@@ -169,13 +163,13 @@ int sbi_misaligned_store_handler(ulong addr, ulong tval2, ulong tinst,
 
        sbi_pmu_ctr_incr_fw(SBI_PMU_FW_MISALIGNED_STORE);
 
-       if (tinst & 0x1) {
+       if (orig_trap->tinst & 0x1) {
                /*
                 * Bit[0] == 1 implies trapped instruction value is
                 * transformed instruction or custom instruction.
                 */
-               insn = tinst | INSN_16BIT_MASK;
-               insn_len = (tinst & 0x2) ? INSN_LEN(insn) : 2;
+               insn     = orig_trap->tinst | INSN_16BIT_MASK;
+               insn_len = (orig_trap->tinst & 0x2) ? INSN_LEN(insn) : 2;
        } else {
                /*
                 * Bit[0] == 0 implies trapped instruction value is

@@ -238,22 +232,16 @@ int sbi_misaligned_store_handler(ulong addr, ulong tval2, ulong tinst,
 #endif
 #endif
        } else {
-               uptrap.epc = regs->mepc;
-               uptrap.cause = CAUSE_MISALIGNED_STORE;
-               uptrap.tval = addr;
-               uptrap.tval2 = tval2;
-               uptrap.tinst = tinst;
-               uptrap.gva   = sbi_regs_gva(regs);
-               return sbi_trap_redirect(regs, &uptrap);
+               return sbi_trap_redirect(regs, orig_trap);
        }
 
        for (i = 0; i < len; i++) {
-               sbi_store_u8((void *)(addr + i), val.data_bytes[i],
+               sbi_store_u8((void *)(orig_trap->tval + i), val.data_bytes[i],
                             &uptrap);
                if (uptrap.cause) {
-                       uptrap.epc = regs->mepc;
+                       uptrap.epc   = regs->mepc;
                        uptrap.tinst = sbi_misaligned_tinst_fixup(
-                               tinst, uptrap.tinst, i);
+                               orig_trap->tinst, uptrap.tinst, i);
                        return sbi_trap_redirect(regs, &uptrap);
                }
        }
--

2.7.4

This patch abstracts out the instruction decoding part of misaligned ld/st fault handlers, so it can be reused by ld/st access fault handlers. Also Added lb/lbu/sb decoding. (previously unreachable by misaligned fault)

sbi_trap_emulate_load/store is now the common handler which takes a emu parameter that is responsible for emulating the misaligned or access fault. The emu callback is expected to fixup the fault, and based on the return code of emu, sbi_trap_emulate_load/store will:

r/wlen => the fixup is successful and regs/mepc needs to be updated.
0 => the fixup is successful, but regs/mepc should be left untouched
(this is usually used if emu does sbi_trap_redirect)
-err => failed, sbi_trap_error will be called

For now, load/store access faults are blindly redirected. It will be enhanced in the following patches.

Signed-off-by Bo Gan <[email protected]>

---
 include/sbi/sbi_trap_ldst.h |  13 +++-
 lib/sbi/sbi_trap.c          |  13 +++-
 lib/sbi/sbi_trap_ldst.c     | 150 ++++++++++++++++++++++++++++++++------------
 3 files changed, 132 insertions(+), 44 deletions(-)

include/sbi/sbi_trap_ldst.h +12 -1

index 5f0ed92..9cab4e4 100644
@@ -13,7 +13,12 @@
 #include <sbi/sbi_types.h>
 #include <sbi/sbi_trap.h>
 
-struct sbi_trap_regs;
+union sbi_ldst_data {
+       u64 data_u64;
+       u32 data_u32;
+       u8 data_bytes[8];
+       ulong data_ulong;
+};
 
 int sbi_misaligned_load_handler(struct sbi_trap_regs *regs,
                                const struct sbi_trap_info *orig_trap);

@@ -21,4 +26,10 @@ int sbi_misaligned_load_handler(struct sbi_trap_regs *regs,
 int sbi_misaligned_store_handler(struct sbi_trap_regs *regs,
                                 const struct sbi_trap_info *orig_trap);
 
+int sbi_load_access_handler(struct sbi_trap_regs *regs,
+                           const struct sbi_trap_info *orig_trap);
+
+int sbi_store_access_handler(struct sbi_trap_regs *regs,
+                            const struct sbi_trap_info *orig_trap);
+
 #endif

lib/sbi/sbi_trap.c +10 -3

index e379984..c665013 100644
@@ -299,10 +299,12 @@ struct sbi_trap_regs *sbi_trap_handler(struct sbi_trap_regs *regs)
                msg = "illegal instruction handler failed";
                break;
        case CAUSE_MISALIGNED_LOAD:
+               sbi_pmu_ctr_incr_fw(SBI_PMU_FW_MISALIGNED_LOAD);
                rc  = sbi_misaligned_load_handler(regs, &trap);
                msg = "misaligned load handler failed";
                break;
        case CAUSE_MISALIGNED_STORE:
+               sbi_pmu_ctr_incr_fw(SBI_PMU_FW_MISALIGNED_STORE);
                rc  = sbi_misaligned_store_handler(regs, &trap);
                msg = "misaligned store handler failed";
                break;

@@ -312,10 +314,15 @@ struct sbi_trap_regs *sbi_trap_handler(struct sbi_trap_regs *regs)
                msg = "ecall handler failed";
                break;
        case CAUSE_LOAD_ACCESS:
+               sbi_pmu_ctr_incr_fw(SBI_PMU_FW_ACCESS_LOAD);
+               rc  = sbi_load_access_handler(regs, &trap);
+               msg = "load fault handler failed";
+               break;
        case CAUSE_STORE_ACCESS:
-               sbi_pmu_ctr_incr_fw(mcause == CAUSE_LOAD_ACCESS ?
-                       SBI_PMU_FW_ACCESS_LOAD : SBI_PMU_FW_ACCESS_STORE);
-               /* fallthrough */
+               sbi_pmu_ctr_incr_fw(SBI_PMU_FW_ACCESS_STORE);
+               rc  = sbi_store_access_handler(regs, &trap);
+               msg = "store fault handler failed";
+               break;
        default:
                /* If the trap came from S or U mode, redirect it there */
                msg = "trap redirect failed";

lib/sbi/sbi_trap_ldst.c +110 -41

index 1fb0ed6..7e4a007 100644
@@ -16,11 +16,23 @@
 #include <sbi/sbi_trap.h>
 #include <sbi/sbi_unpriv.h>
 
-union reg_data {
-       u8 data_bytes[8];
-       ulong data_ulong;
-       u64 data_u64;
-};
+/**
+ * Load emulator callback:
+ *
+ * @return rlen=success, 0=success w/o regs modification, or negative error
+ */
+typedef int (*sbi_trap_ld_emulator)(int rlen, union sbi_ldst_data *out_val,
+                                   struct sbi_trap_regs *regs,
+                                   const struct sbi_trap_info *orig_trap);
+
+/**
+ * Store emulator callback:
+ *
+ * @return wlen=success, 0=success w/o regs modification, or negative error
+ */
+typedef int (*sbi_trap_st_emulator)(int wlen, union sbi_ldst_data in_val,
+                                   struct sbi_trap_regs *regs,
+                                   const struct sbi_trap_info *orig_trap);
 
 static ulong sbi_misaligned_tinst_fixup(ulong orig_tinst, ulong new_tinst,
                                        ulong addr_offset)

@@ -34,15 +46,14 @@ static ulong sbi_misaligned_tinst_fixup(ulong orig_tinst, ulong new_tinst,
                return orig_tinst | (addr_offset << SH_RS1);
 }
 
-int sbi_misaligned_load_handler(struct sbi_trap_regs *regs,
-                               const struct sbi_trap_info *orig_trap)
+static int sbi_trap_emulate_load(struct sbi_trap_regs *regs,
+                                const struct sbi_trap_info *orig_trap,
+                                sbi_trap_ld_emulator emu)
 {
        ulong insn, insn_len;
-       union reg_data val;
+       union sbi_ldst_data val = { 0 };
        struct sbi_trap_info uptrap;
-       int i, fp = 0, shift = 0, len = 0;
-
-       sbi_pmu_ctr_incr_fw(SBI_PMU_FW_MISALIGNED_LOAD);
+       int rc, fp = 0, shift = 0, len = 0;
 
        if (orig_trap->tinst & 0x1) {
                /*

@@ -64,7 +75,12 @@ int sbi_misaligned_load_handler(struct sbi_trap_regs *regs,
                insn_len = INSN_LEN(insn);
        }
 
-       if ((insn & INSN_MASK_LW) == INSN_MATCH_LW) {
+       if ((insn & INSN_MASK_LB) == INSN_MATCH_LB) {
+               len   = 1;
+               shift = 8 * (sizeof(ulong) - len);
+       } else if ((insn & INSN_MASK_LBU) == INSN_MATCH_LBU) {
+               len = 1;
+       } else if ((insn & INSN_MASK_LW) == INSN_MATCH_LW) {
                len   = 4;
                shift = 8 * (sizeof(ulong) - len);
 #if __riscv_xlen == 64

@@ -127,17 +143,10 @@ int sbi_misaligned_load_handler(struct sbi_trap_regs *regs,
                return sbi_trap_redirect(regs, orig_trap);
        }
 
-       val.data_u64 = 0;
-       for (i = 0; i < len; i++) {
-               val.data_bytes[i] =
-                       sbi_load_u8((void *)(orig_trap->tval + i), &uptrap);
-               if (uptrap.cause) {
-                       uptrap.epc   = regs->mepc;
-                       uptrap.tinst = sbi_misaligned_tinst_fixup(
-                               orig_trap->tinst, uptrap.tinst, i);
-                       return sbi_trap_redirect(regs, &uptrap);
-               }
-       }
+       rc = emu(len, &val, regs, orig_trap);
+
+       if (rc <= 0)
+               return rc;
 
        if (!fp)
                SET_RD(insn, regs, ((long)(val.data_ulong << shift)) >> shift);

@@ -153,15 +162,14 @@ int sbi_misaligned_load_handler(struct sbi_trap_regs *regs,
        return 0;
 }
 
-int sbi_misaligned_store_handler(struct sbi_trap_regs *regs,
-                                const struct sbi_trap_info *orig_trap)
+static int sbi_trap_emulate_store(struct sbi_trap_regs *regs,
+                                 const struct sbi_trap_info *orig_trap,
+                                 sbi_trap_st_emulator emu)
 {
        ulong insn, insn_len;
-       union reg_data val;
+       union sbi_ldst_data val;
        struct sbi_trap_info uptrap;
-       int i, len = 0;
-
-       sbi_pmu_ctr_incr_fw(SBI_PMU_FW_MISALIGNED_STORE);
+       int rc, len = 0;
 
        if (orig_trap->tinst & 0x1) {
                /*

@@ -185,7 +193,9 @@ int sbi_misaligned_store_handler(struct sbi_trap_regs *regs,
 
        val.data_ulong = GET_RS2(insn, regs);
 
-       if ((insn & INSN_MASK_SW) == INSN_MATCH_SW) {
+       if ((insn & INSN_MASK_SB) == INSN_MATCH_SB) {
+               len = 1;
+       } else if ((insn & INSN_MASK_SW) == INSN_MATCH_SW) {
                len = 4;
 #if __riscv_xlen == 64
        } else if ((insn & INSN_MASK_SD) == INSN_MATCH_SD) {

@@ -235,18 +245,78 @@ int sbi_misaligned_store_handler(struct sbi_trap_regs *regs,
                return sbi_trap_redirect(regs, orig_trap);
        }
 
-       for (i = 0; i < len; i++) {
-               sbi_store_u8((void *)(orig_trap->tval + i), val.data_bytes[i],
-                            &uptrap);
-               if (uptrap.cause) {
-                       uptrap.epc   = regs->mepc;
-                       uptrap.tinst = sbi_misaligned_tinst_fixup(
-                               orig_trap->tinst, uptrap.tinst, i);
-                       return sbi_trap_redirect(regs, &uptrap);
-               }
-       }
+       rc = emu(len, val, regs, orig_trap);
+
+       if (rc <= 0)
+               return rc;
 
        regs->mepc += insn_len;
 
        return 0;
 }
+
+static int sbi_misaligned_ld_emulator(int rlen, union sbi_ldst_data *out_val,
+                                     struct sbi_trap_regs *regs,
+                                     const struct sbi_trap_info *orig_trap)
+{
+       struct sbi_trap_info uptrap;
+       int i;
+
+       for (i = 0; i < rlen; i++) {
+               out_val->data_bytes[i] =
+                       sbi_load_u8((void *)(orig_trap->tval + i), &uptrap);
+               if (uptrap.cause) {
+                       uptrap.epc   = regs->mepc;
+                       uptrap.tinst = sbi_misaligned_tinst_fixup(
+                               orig_trap->tinst, uptrap.tinst, i);
+                       return sbi_trap_redirect(regs, &uptrap);
+               }
+       }
+       return rlen;
+}
+
+int sbi_misaligned_load_handler(struct sbi_trap_regs *regs,
+                               const struct sbi_trap_info *orig_trap)
+{
+       return sbi_trap_emulate_load(regs, orig_trap,
+                                    sbi_misaligned_ld_emulator);
+}
+
+static int sbi_misaligned_st_emulator(int wlen, union sbi_ldst_data in_val,
+                                     struct sbi_trap_regs *regs,
+                                     const struct sbi_trap_info *orig_trap)
+{
+       struct sbi_trap_info uptrap;
+       int i;
+
+       for (i = 0; i < wlen; i++) {
+               sbi_store_u8((void *)(orig_trap->tval + i),
+                            in_val.data_bytes[i], &uptrap);
+               if (uptrap.cause) {
+                       uptrap.epc   = regs->mepc;
+                       uptrap.tinst = sbi_misaligned_tinst_fixup(
+                               orig_trap->tinst, uptrap.tinst, i);
+                       return sbi_trap_redirect(regs, &uptrap);
+               }
+       }
+       return wlen;
+}
+
+int sbi_misaligned_store_handler(struct sbi_trap_regs *regs,
+                                const struct sbi_trap_info *orig_trap)
+{
+       return sbi_trap_emulate_store(regs, orig_trap,
+                                     sbi_misaligned_st_emulator);
+}
+
+int sbi_load_access_handler(struct sbi_trap_regs *regs,
+                           const struct sbi_trap_info *orig_trap)
+{
+       return sbi_trap_redirect(regs, orig_trap);
+}
+
+int sbi_store_access_handler(struct sbi_trap_regs *regs,
+                            const struct sbi_trap_info *orig_trap)
+{
+       return sbi_trap_redirect(regs, orig_trap);
+}
--

2.7.4

This patch allows the platform to define load/store emulators. This enables a platform to trap-and-emulate special devices or filter access to existing physical devices.

Signed-off-by Bo Gan <[email protected]>

---
 include/sbi/sbi_platform.h | 8 ++++++++
 1 file changed, 8 insertions(+)

include/sbi/sbi_platform.h +8 -1

index 2fb33e1..f962aa4 100644
@@ -53,6 +53,7 @@ struct sbi_domain_memregion;
 struct sbi_ecall_return;
 struct sbi_trap_regs;
 struct sbi_hart_features;
+union sbi_ldst_data;
 
 /** Possible feature flags of a platform */
 enum sbi_platform_features {

@@ -139,6 +140,13 @@ struct sbi_platform_operations {
        int (*vendor_ext_provider)(long funcid,
                                   struct sbi_trap_regs *regs,
                                   struct sbi_ecall_return *out);
+
+       /** platform specific handler to fixup load fault */
+       int (*emulate_load)(int rlen, unsigned long addr,
+                           union sbi_ldst_data *out_val);
+       /** platform specific handler to fixup store fault */
+       int (*emulate_store)(int wlen, unsigned long addr,
+                            union sbi_ldst_data in_val);
 };
 
 /** Platform default per-HART stack size for exception/interrupt handling */
--

2.7.4

sbi_load/store_access_handler now tries to call platform emulators if defined. Otherwise, redirects the fault. If the platform code returns failure, this means the H/S/U has accessed the emulated devices in an unexpected manner, which is very likely caused by buggy code in H/S/U. We redirect the fault, so lower privileged level can get notified, and act accordingly. (E.g., oops in Linux)

We let the handler truly fail if the trap was originated from M mode. In this case, something must be very wrong and we should just fail.

Signed-off-by Bo Gan <[email protected]>

---
 include/sbi/sbi_platform.h | 45 +++++++++++++++++++++++++++++++++++++++++++++
 lib/sbi/sbi_trap_ldst.c    | 37 +++++++++++++++++++++++++++++++++++--
 2 files changed, 80 insertions(+), 2 deletions(-)

include/sbi/sbi_platform.h +45 -0

index f962aa4..581935a 100644
@@ -48,6 +48,7 @@
 #include <sbi/sbi_error.h>
 #include <sbi/sbi_scratch.h>
 #include <sbi/sbi_version.h>
+#include <sbi/sbi_trap_ldst.h>
 
 struct sbi_domain_memregion;
 struct sbi_ecall_return;

@@ -683,6 +684,50 @@ static inline int sbi_platform_vendor_ext_provider(
        return SBI_ENOTSUPP;
 }
 
+/**
+ * Ask platform to emulate the trapped load
+ *
+ * @param plat pointer to struct sbi_platform
+ * @param rlen length of the load: 1/2/4/8...
+ * @param addr virtual address of the load. Platform needs to page-walk and
+ *        find the physical address if necessary
+ * @param out_val value loaded
+ *
+ * @return 0 on success and negative error code on failure
+ */
+static inline int sbi_platform_emulate_load(const struct sbi_platform *plat,
+                                           int rlen, unsigned long addr,
+                                           union sbi_ldst_data *out_val)
+{
+       if (plat && sbi_platform_ops(plat)->emulate_load) {
+               return sbi_platform_ops(plat)->emulate_load(rlen, addr,
+                                                           out_val);
+       }
+       return SBI_ENOTSUPP;
+}
+
+/**
+ * Ask platform to emulate the trapped store
+ *
+ * @param plat pointer to struct sbi_platform
+ * @param wlen length of the store: 1/2/4/8...
+ * @param addr virtual address of the store. Platform needs to page-walk and
+ *        find the physical address if necessary
+ * @param in_val value to store
+ *
+ * @return 0 on success and negative error code on failure
+ */
+static inline int sbi_platform_emulate_store(const struct sbi_platform *plat,
+                                            int wlen, unsigned long addr,
+                                            union sbi_ldst_data in_val)
+{
+       if (plat && sbi_platform_ops(plat)->emulate_store) {
+               return sbi_platform_ops(plat)->emulate_store(wlen, addr,
+                                                            in_val);
+       }
+       return SBI_ENOTSUPP;
+}
+
 #endif
 
 #endif

lib/sbi/sbi_trap_ldst.c +35 -3

index 7e4a007..0425ccb 100644
@@ -15,6 +15,7 @@
 #include <sbi/sbi_pmu.h>
 #include <sbi/sbi_trap.h>
 #include <sbi/sbi_unpriv.h>
+#include <sbi/sbi_platform.h>
 
 /**
  * Load emulator callback:

@@ -309,14 +310,46 @@ int sbi_misaligned_store_handler(struct sbi_trap_regs *regs,
                                      sbi_misaligned_st_emulator);
 }
 
+static int sbi_ld_access_emulator(int rlen, union sbi_ldst_data *out_val,
+                                 struct sbi_trap_regs *regs,
+                                 const struct sbi_trap_info *orig_trap)
+{
+       /* If fault came from M mode, just fail */
+       if (((regs->mstatus & MSTATUS_MPP) >> MSTATUS_MPP_SHIFT) == PRV_M)
+               return SBI_EINVAL;
+
+       /* If platform emulator failed, we redirect instead of fail */
+       if (sbi_platform_emulate_load(sbi_platform_thishart_ptr(), rlen,
+                                     orig_trap->tval, out_val))
+               return sbi_trap_redirect(regs, orig_trap);
+
+       return rlen;
+}
+
 int sbi_load_access_handler(struct sbi_trap_regs *regs,
                            const struct sbi_trap_info *orig_trap)
 {
-       return sbi_trap_redirect(regs, orig_trap);
+       return sbi_trap_emulate_load(regs, orig_trap, sbi_ld_access_emulator);
+}
+
+static int sbi_st_access_emulator(int wlen, union sbi_ldst_data in_val,
+                                 struct sbi_trap_regs *regs,
+                                 const struct sbi_trap_info *orig_trap)
+{
+       /* If fault came from M mode, just fail */
+       if (((regs->mstatus & MSTATUS_MPP) >> MSTATUS_MPP_SHIFT) == PRV_M)
+               return SBI_EINVAL;
+
+       /* If platform emulator failed, we redirect instead of fail */
+       if (sbi_platform_emulate_store(sbi_platform_thishart_ptr(), wlen,
+                                      orig_trap->tval, in_val))
+               return sbi_trap_redirect(regs, orig_trap);
+
+       return wlen;
 }
 
 int sbi_store_access_handler(struct sbi_trap_regs *regs,
                             const struct sbi_trap_info *orig_trap)
 {
-       return sbi_trap_redirect(regs, orig_trap);
+       return sbi_trap_emulate_store(regs, orig_trap, sbi_st_access_emulator);
 }
--

2.7.4

Sometimes a platform wants to trap-n-emulate special devices or filter access to physical devices. This patch makes sbi_trap_handler to call platform_ops.emulate_load/store and ask platform to fixup the fault.

v4 changes:

(quoted diff) +0 -2

-  Addressed comments from Anup -- sbi_trap related details should
   not be visable to platform code.
-  Minor fixes -- splitting patches and renames suggested by Anup.

v3 changes:

(quoted diff) +0 -2

-  Addressed comments from Anup by breaking down the patchset and
   new sbi_platform_emulate_load/store helper functions.
-  Reworked the return value of sbi_trap_ld/st_emulator to support
   (>0) successful emulation (==0) trap_redirect (<0) real failure.

v2 changes:

(quoted diff) +0 -2

-  Added const qualifier to *orig_trap on load/store fault handlers.
   That addressed Xiang W's comment.
-  Applied clang-format to changed lines.

Bo Gan (7):
lib: sbi: rename sbi_misaligned_ldst.c to sbi_trap_ldst.c
include: sbi: rename sbi_misaligned_ldst.h to sbi_trap_ldst.h
lib: sbi: change prototype of sbi_trap_redirect
lib: sbi: change prototype of sbi_misaligned_load/store_handler
lib: sbi: abstract out insn decoding to unify mem fault handlers
include: sbi: add emulate_load/store handler to platform ops
lib: sbi: call platform load/store emulators

 include/sbi/sbi_misaligned_ldst.h                  |  23 ---
 include/sbi/sbi_platform.h                         |  53 +++++
 include/sbi/sbi_trap.h                             |   2 +-
 include/sbi/sbi_trap_ldst.h                        |  35 ++++
 lib/sbi/objects.mk                                 |   2 +-
 lib/sbi/sbi_trap.c                                 |  38 ++--
 lib/sbi/{sbi_misaligned_ldst.c => sbi_trap_ldst.c} | 213 +++++++++++++++------
 7 files changed, 265 insertions(+), 101 deletions(-)
 delete mode 100644 include/sbi/sbi_misaligned_ldst.h
 create mode 100644 include/sbi/sbi_trap_ldst.h
 rename lib/sbi/{sbi_misaligned_ldst.c => sbi_trap_ldst.c} (54%)

--
2.7.4