Now that kernel correctly store/restore userspace AMR/IAMR values, avoid
manipulating AMR and IAMR from the kernel on behalf of userspace.

Signed-off-by: Aneesh Kumar K.V <aneesh.ku...@linux.ibm.com>
---
 arch/powerpc/include/asm/book3s/64/kup.h | 23 ++++++++
 arch/powerpc/include/asm/processor.h     |  5 --
 arch/powerpc/kernel/process.c            |  4 --
 arch/powerpc/kernel/traps.c              |  6 --
 arch/powerpc/mm/book3s64/pkeys.c         | 71 ++++--------------------
 5 files changed, 34 insertions(+), 75 deletions(-)

diff --git a/arch/powerpc/include/asm/book3s/64/kup.h 
b/arch/powerpc/include/asm/book3s/64/kup.h
index fe1818954e51..31eb0acddea9 100644
--- a/arch/powerpc/include/asm/book3s/64/kup.h
+++ b/arch/powerpc/include/asm/book3s/64/kup.h
@@ -174,6 +174,29 @@ extern u64 default_uamor;
 extern u64 default_amr;
 extern u64 default_iamr;
 
+/*
+ * For kernel thread that doesn't have thread.regs return
+ * default AMR/IAMR values.
+ */
+static inline u64 current_thread_amr(void)
+{
+       if (current->thread.regs)
+               return current->thread.regs->kuap;
+       return AMR_KUAP_BLOCKED;
+}
+
+static inline u64 current_thread_iamr(void)
+{
+       if (current->thread.regs)
+               return current->thread.regs->kuep;
+       return AMR_KUEP_BLOCKED;
+}
+
+static inline u64 read_uamor(void)
+{
+       return default_uamor;
+}
+
 static inline void kuap_restore_user_amr(struct pt_regs *regs)
 {
        if (!mmu_has_feature(MMU_FTR_PKEY))
diff --git a/arch/powerpc/include/asm/processor.h 
b/arch/powerpc/include/asm/processor.h
index a51964b4ec42..591987da44e2 100644
--- a/arch/powerpc/include/asm/processor.h
+++ b/arch/powerpc/include/asm/processor.h
@@ -234,11 +234,6 @@ struct thread_struct {
        struct thread_vr_state ckvr_state; /* Checkpointed VR state */
        unsigned long   ckvrsave; /* Checkpointed VRSAVE */
 #endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
-#ifdef CONFIG_PPC_MEM_KEYS
-       unsigned long   amr;
-       unsigned long   iamr;
-       unsigned long   uamor;
-#endif
 #ifdef CONFIG_KVM_BOOK3S_32_HANDLER
        void*           kvm_shadow_vcpu; /* KVM internal data */
 #endif /* CONFIG_KVM_BOOK3S_32_HANDLER */
diff --git a/arch/powerpc/kernel/process.c b/arch/powerpc/kernel/process.c
index 0ab9a8cf1bcb..682deeee421f 100644
--- a/arch/powerpc/kernel/process.c
+++ b/arch/powerpc/kernel/process.c
@@ -585,7 +585,6 @@ static void save_all(struct task_struct *tsk)
                __giveup_spe(tsk);
 
        msr_check_and_clear(msr_all_available);
-       thread_pkey_regs_save(&tsk->thread);
 }
 
 void flush_all_to_thread(struct task_struct *tsk)
@@ -1097,8 +1096,6 @@ static inline void save_sprs(struct thread_struct *t)
                t->tar = mfspr(SPRN_TAR);
        }
 #endif
-
-       thread_pkey_regs_save(t);
 }
 
 static inline void restore_sprs(struct thread_struct *old_thread,
@@ -1139,7 +1136,6 @@ static inline void restore_sprs(struct thread_struct 
*old_thread,
                mtspr(SPRN_TIDR, new_thread->tidr);
 #endif
 
-       thread_pkey_regs_restore(new_thread, old_thread);
 }
 
 struct task_struct *__switch_to(struct task_struct *prev,
diff --git a/arch/powerpc/kernel/traps.c b/arch/powerpc/kernel/traps.c
index 3fca22276bb1..a47fb49b7af8 100644
--- a/arch/powerpc/kernel/traps.c
+++ b/arch/powerpc/kernel/traps.c
@@ -348,12 +348,6 @@ static bool exception_common(int signr, struct pt_regs 
*regs, int code,
 
        current->thread.trap_nr = code;
 
-       /*
-        * Save all the pkey registers AMR/IAMR/UAMOR. Eg: Core dumps need
-        * to capture the content, if the task gets killed.
-        */
-       thread_pkey_regs_save(&current->thread);
-
        return true;
 }
 
diff --git a/arch/powerpc/mm/book3s64/pkeys.c b/arch/powerpc/mm/book3s64/pkeys.c
index 5012b57af808..0f4fc2876fc8 100644
--- a/arch/powerpc/mm/book3s64/pkeys.c
+++ b/arch/powerpc/mm/book3s64/pkeys.c
@@ -264,40 +264,17 @@ void pkey_mm_init(struct mm_struct *mm)
        mm->context.execute_only_pkey = execute_only_key;
 }
 
-static inline u64 read_amr(void)
+static inline void update_current_thread_amr(u64 value)
 {
-       return mfspr(SPRN_AMR);
+       current->thread.regs->kuap = value;
 }
 
-static inline void write_amr(u64 value)
-{
-       mtspr(SPRN_AMR, value);
-}
-
-static inline u64 read_iamr(void)
-{
-       if (static_branch_unlikely(&execute_pkey_disabled))
-               return 0x0UL;
-
-       return mfspr(SPRN_IAMR);
-}
-
-static inline void write_iamr(u64 value)
+static inline void update_current_thread_iamr(u64 value)
 {
        if (static_branch_unlikely(&execute_pkey_disabled))
                return;
 
-       mtspr(SPRN_IAMR, value);
-}
-
-static inline u64 read_uamor(void)
-{
-       return mfspr(SPRN_UAMOR);
-}
-
-static inline void write_uamor(u64 value)
-{
-       mtspr(SPRN_UAMOR, value);
+       current->thread.regs->kuep = value;
 }
 
 static bool is_pkey_enabled(int pkey)
@@ -314,20 +291,21 @@ static bool is_pkey_enabled(int pkey)
        return !!(uamor_pkey_bits);
 }
 
+/*  FIXME!! what happens to other threads AMR value? */
 static inline void init_amr(int pkey, u8 init_bits)
 {
        u64 new_amr_bits = (((u64)init_bits & 0x3UL) << pkeyshift(pkey));
-       u64 old_amr = read_amr() & ~((u64)(0x3ul) << pkeyshift(pkey));
+       u64 old_amr = current_thread_amr() & ~((u64)(0x3ul) << pkeyshift(pkey));
 
-       write_amr(old_amr | new_amr_bits);
+       update_current_thread_amr(old_amr | new_amr_bits);
 }
 
 static inline void init_iamr(int pkey, u8 init_bits)
 {
        u64 new_iamr_bits = (((u64)init_bits & 0x1UL) << pkeyshift(pkey));
-       u64 old_iamr = read_iamr() & ~((u64)(0x1ul) << pkeyshift(pkey));
+       u64 old_iamr = current_thread_iamr() & ~((u64)(0x1ul) << 
pkeyshift(pkey));
 
-       write_iamr(old_iamr | new_iamr_bits);
+       update_current_thread_iamr(old_iamr | new_iamr_bits);
 }
 
 /*
@@ -360,33 +338,6 @@ int __arch_set_user_pkey_access(struct task_struct *tsk, 
int pkey,
        return 0;
 }
 
-void thread_pkey_regs_save(struct thread_struct *thread)
-{
-       if (!mmu_has_feature(MMU_FTR_PKEY))
-               return;
-
-       /*
-        * TODO: Skip saving registers if @thread hasn't used any keys yet.
-        */
-       thread->amr = read_amr();
-       thread->iamr = read_iamr();
-       thread->uamor = read_uamor();
-}
-
-void thread_pkey_regs_restore(struct thread_struct *new_thread,
-                             struct thread_struct *old_thread)
-{
-       if (!mmu_has_feature(MMU_FTR_PKEY))
-               return;
-
-       if (old_thread->amr != new_thread->amr)
-               write_amr(new_thread->amr);
-       if (old_thread->iamr != new_thread->iamr)
-               write_iamr(new_thread->iamr);
-       if (old_thread->uamor != new_thread->uamor)
-               write_uamor(new_thread->uamor);
-}
-
 int execute_only_pkey(struct mm_struct *mm)
 {
        if (static_branch_likely(&execute_pkey_disabled))
@@ -440,10 +391,10 @@ static bool pkey_access_permitted(int pkey, bool write, 
bool execute)
                return true;
 
        pkey_shift = pkeyshift(pkey);
-       if (execute && !(read_iamr() & (IAMR_EX_BIT << pkey_shift)))
+       if (execute && !(current_thread_iamr() & (IAMR_EX_BIT << pkey_shift)))
                return true;
 
-       amr = read_amr(); /* Delay reading amr until absolutely needed */
+       amr = current_thread_amr();
        return ((!write && !(amr & (AMR_RD_BIT << pkey_shift))) ||
                (write &&  !(amr & (AMR_WR_BIT << pkey_shift))));
 }
-- 
2.26.2

Reply via email to