[pk] proxy kernel support for mixed 32b/64b operation

6 files changed, 119 insertions, 79 deletions

diff --git a/pk/entry.S b/pk/entry.S
index b52ff15..8e85a81 100644
--- a/pk/entry.S
+++ b/pk/entry.S
@@ -1,44 +1,58 @@
+#include "pcr.h"
+
+#ifdef PK_ENABLE_KERNEL_64BIT
+# define STORE    sd
+# define LOAD     ld
+# define REGBYTES 8
+#else
+# define STORE    sw
+# define LOAD     lw
+# define REGBYTES 4
+#endif
+
 	.text
 	.set	noat
 	.ent	save_tf
 save_tf:	# write the trap frame onto the stack
+
 	# save gprs
-	sd		$1,8($k1)
-	sd		$2,16($k1)
-	sd		$3,24($k1)
-	sd		$4,32($k1)
-	sd		$5,40($k1)
-	sd		$6,48($k1)
-	sd		$7,56($k1)
-	sd		$8,64($k1)
-	sd		$9,72($k1)
-	sd		$10,80($k1)
-	sd		$11,88($k1)
-	sd		$12,96($k1)
-	sd		$13,104($k1)
-	sd		$14,112($k1)
-	sd		$15,120($k1)
-	sd		$16,128($k1)
-	sd		$17,136($k1)
-	sd		$18,144($k1)
-	sd		$19,152($k1)
-	sd		$20,160($k1)
-	sd		$21,168($k1)
-	sd		$22,176($k1)
-	sd		$23,184($k1)
-	sd		$24,192($k1)
-	sd		$25,200($k1)
-	sd		$28,224($k1)
-	sd		$29,232($k1)
-	sd		$30,240($k1)
-	sd		$k0,248($k1)	# $ra is actually in $k0
+	STORE	$1,1*REGBYTES($k1)
+	STORE	$2,2*REGBYTES($k1)
+	STORE	$3,3*REGBYTES($k1)
+	STORE	$4,4*REGBYTES($k1)
+	STORE	$5,5*REGBYTES($k1)
+	STORE	$6,6*REGBYTES($k1)
+	STORE	$7,7*REGBYTES($k1)
+	STORE	$8,8*REGBYTES($k1)
+	STORE	$9,9*REGBYTES($k1)
+	STORE	$10,10*REGBYTES($k1)
+	STORE	$11,11*REGBYTES($k1)
+	STORE	$12,12*REGBYTES($k1)
+	STORE	$13,13*REGBYTES($k1)
+	STORE	$14,14*REGBYTES($k1)
+	STORE	$15,15*REGBYTES($k1)
+	STORE	$16,16*REGBYTES($k1)
+	STORE	$17,17*REGBYTES($k1)
+	STORE	$18,18*REGBYTES($k1)
+	STORE	$19,19*REGBYTES($k1)
+	STORE	$20,20*REGBYTES($k1)
+	STORE	$21,21*REGBYTES($k1)
+	STORE	$22,22*REGBYTES($k1)
+	STORE	$23,23*REGBYTES($k1)
+	STORE	$24,24*REGBYTES($k1)
+	STORE	$25,25*REGBYTES($k1)
+	STORE	$28,28*REGBYTES($k1)
+	STORE	$29,29*REGBYTES($k1)
+	STORE	$30,30*REGBYTES($k1)
+	STORE	$k0,31*REGBYTES($k1)	# $ra is actually in $k0
+
 	# get sr, epc, badvaddr
-	mfpcr	$t0,$0			# sr
-	sd		$t0,256($k1)
-	mfpcr	$t0,$1			# epc
-	sd		$t0,264($k1)
-	mfpcr	$t0,$2			# badvaddr
-	sd		$t0,272($k1)
+	mfpcr	$t0,$PCR_SR					# sr
+	STORE	$t0,32*REGBYTES($k1)
+	mfpcr	$t0,$PCR_EPC					# epc
+	STORE	$t0,33*REGBYTES($k1)
+	mfpcr	$t0,$PCR_BADVADDR			# badvaddr
+	STORE	$t0,34*REGBYTES($k1)
 	jr		$ra
 	.end	save_tf
 
@@ -46,43 +60,43 @@ save_tf:	# write the trap frame onto the stack
 	.ent	pop_tf
 pop_tf:	# write the trap frame onto the stack
 	# restore gprs
-	ld		$t0,256($a0)	# restore sr, which should disable interrupts
-	mtpcr	$t0,$0
+	LOAD	$t0,32*REGBYTES($a0)	# restore sr (should disable interrupts)
+	mtpcr	$t0,$PCR_SR
 
 	move	$k0,$a0
-	ld		$1,8($k0)
-	ld		$2,16($k0)
-	ld		$3,24($k0)
-	ld		$4,32($k0)
-	ld		$5,40($k0)
-	ld		$6,48($k0)
-	ld		$7,56($k0)
-	ld		$8,64($k0)
-	ld		$9,72($k0)
-	ld		$10,80($k0)
-	ld		$11,88($k0)
-	ld		$12,96($k0)
-	ld		$13,104($k0)
-	ld		$14,112($k0)
-	ld		$15,120($k0)
-	ld		$16,128($k0)
-	ld		$17,136($k0)
-	ld		$18,144($k0)
-	ld		$19,152($k0)
-	ld		$20,160($k0)
-	ld		$21,168($k0)
-	ld		$22,176($k0)
-	ld		$23,184($k0)
-	ld		$24,192($k0)
-	ld		$25,200($k0)
-	ld		$28,224($k0)
-	ld		$29,232($k0)
-	ld		$30,240($k0)
-	ld		$31,248($k0)
+	LOAD	$1,1*REGBYTES($k0)
+	LOAD	$2,2*REGBYTES($k0)
+	LOAD	$3,3*REGBYTES($k0)
+	LOAD	$4,4*REGBYTES($k0)
+	LOAD	$5,5*REGBYTES($k0)
+	LOAD	$6,6*REGBYTES($k0)
+	LOAD	$7,7*REGBYTES($k0)
+	LOAD	$8,8*REGBYTES($k0)
+	LOAD	$9,9*REGBYTES($k0)
+	LOAD	$10,10*REGBYTES($k0)
+	LOAD	$11,11*REGBYTES($k0)
+	LOAD	$12,12*REGBYTES($k0)
+	LOAD	$13,13*REGBYTES($k0)
+	LOAD	$14,14*REGBYTES($k0)
+	LOAD	$15,15*REGBYTES($k0)
+	LOAD	$16,16*REGBYTES($k0)
+	LOAD	$17,17*REGBYTES($k0)
+	LOAD	$18,18*REGBYTES($k0)
+	LOAD	$19,19*REGBYTES($k0)
+	LOAD	$20,20*REGBYTES($k0)
+	LOAD	$21,21*REGBYTES($k0)
+	LOAD	$22,22*REGBYTES($k0)
+	LOAD	$23,23*REGBYTES($k0)
+	LOAD	$24,24*REGBYTES($k0)
+	LOAD	$25,25*REGBYTES($k0)
+	LOAD	$28,28*REGBYTES($k0)
+	LOAD	$29,29*REGBYTES($k0)
+	LOAD	$30,30*REGBYTES($k0)
+	LOAD	$31,31*REGBYTES($k0)
 
 	# gtfo!
-	ld		$k0,264($k0)
-	mtpcr	$k0,$1
+	LOAD	$k0,33*REGBYTES($k0)
+	mtpcr	$k0,$PCR_EPC
 	eret
 	.end	pop_tf
 
@@ -90,9 +104,7 @@ pop_tf:	# write the trap frame onto the stack
 
 	#define TRAP_TABLE_ENTRY(x) \
 	.align	7; \
-	.set at=$k0; \
-	la		$k1,stack_top-320; \
-	.set noat; \
+	law		$k1,stack_top-320; \
 	move	$k0,$ra; \
 	jal		save_tf; \
 	move	$sp,$k1; \
diff --git a/pk/frontend.c b/pk/frontend.c
index c4e799b..f02ed0d 100644
--- a/pk/frontend.c
+++ b/pk/frontend.c
@@ -2,10 +2,11 @@
 #include "atomic.h"
 #include "frontend.h"
 #include "pcr.h"
+#include <stdint.h>
 
 sysret_t frontend_syscall(long n, long a0, long a1, long a2, long a3)
 {
-  static volatile long magic_mem[8];
+  static volatile uint64_t magic_mem[8];
 
   static spinlock_t lock = SPINLOCK_INIT;
   spinlock_lock(&lock);
diff --git a/pk/pcr.h b/pk/pcr.h
index 2014dfc..4137dcd 100644
--- a/pk/pcr.h
+++ b/pk/pcr.h
@@ -1,6 +1,8 @@
 #ifndef _RISCV_COP0_H
 #define _RISCV_COP0_H
 
+#include "config.h"
+
 #define SR_ET    0x0000000000000001
 #define SR_PS    0x0000000000000004
 #define SR_S     0x0000000000000008
@@ -9,17 +11,19 @@
 #define SR_KX    0x0000000000000040
 #define SR_IM    0x000000000000FF00
 
-#define PCR_SR 0
-#define PCR_TBR 3
+#define PCR_SR       0
+#define PCR_EPC      1
+#define PCR_BADVADDR 2
+#define PCR_TBR      3
 
 #ifndef __ASSEMBLER__
 
 #define mtpcr(val,reg) ({ long __tmp = (long)(val); \
-                          asm volatile ("mtpcr %0,$%1"::"r"(__tmp),"i"(reg)); })
+          asm volatile ("mtpcr %0,$%1"::"r"(__tmp),"i"(reg)); })
 
 #define mfpcr(reg) ({ long __tmp; \
-                      asm volatile ("mfpcr %0,$%1" : "=r"(__tmp) : "i"(reg)); \
-                      __tmp; })
+          asm volatile ("mfpcr %0,$%1" : "=r"(__tmp) : "i"(reg)); \
+          __tmp; })
 
 #endif
 
diff --git a/pk/pk.ac b/pk/pk.ac
index e69de29..94fb63a 100644
--- a/pk/pk.ac
+++ b/pk/pk.ac
@@ -0,0 +1,17 @@
+AC_ARG_ENABLE([vm], AS_HELP_STRING([--disable-vm], [Disable virtual memory]))
+AS_IF([test "x$enable_vm" != "xno"], [
+  AC_DEFINE([PK_ENABLE_VM],,[Define if virtual memory support is enabled])
+])
+
+AC_ARG_ENABLE([kernel-64bit], AS_HELP_STRING([--disable-kernel-64bit], [Disable 64-bit kernel operation]))
+AS_IF([test "x$enable_kernel_64bit" != "xno"], [
+  AC_DEFINE([PK_ENABLE_KERNEL_64BIT],,[Define if the kernel runs in 64-bit mode])
+],[
+  AC_SUBST([CFLAGS],["$CFLAGS -mabi=32"])
+  AC_SUBST([LDFLAGS],["$LDFLAGS -mabi=32"])
+])
+
+AC_ARG_ENABLE([user-64bit], AS_HELP_STRING([--disable-user-64bit], [Disable 64-bit user operation]))
+AS_IF([test "x$enable_user_64bit" != "xno"], [
+  AC_DEFINE([PK_ENABLE_USER_64BIT],,[Define if the user runs in 64-bit mode])
+])
diff --git a/pk/pk.c b/pk/pk.c
index 2f0ba17..9508286 100644
--- a/pk/pk.c
+++ b/pk/pk.c
@@ -123,7 +123,7 @@ void dump_tf(trapframe_t* tf)
 void init_tf(trapframe_t* tf, long pc, long sp)
 {
   memset(tf,0,sizeof(*tf));
-  tf->sr = SR_S | SR_KX | SR_UX; // SR_PS=0 (usermode); SR_ET=0
+  tf->sr = mfpcr(PCR_SR) & ~(SR_PS | SR_ET);
   tf->gpr[29] = USER_MEM_SIZE-USER_MAINVARS_SIZE;
   tf->epc = USER_START;
 }
diff --git a/pk/riscv-pk.c b/pk/riscv-pk.c
index dfcc71d..8168b33 100644
--- a/pk/riscv-pk.c
+++ b/pk/riscv-pk.c
@@ -5,7 +5,13 @@ void __attribute__((section(".boottext"))) __start()
   extern char stack_top;
   asm("move $sp,%0" : : "r"(&stack_top-64));
 
-  register long sr0 = SR_S | SR_PS | SR_ET | SR_UX | SR_KX;
+  register long sr0 = SR_S | SR_PS | SR_ET;
+  #ifdef PK_ENABLE_KERNEL_64BIT
+    sr0 |= SR_KX;
+    #ifdef PK_ENABLE_USER_64BIT
+      sr0 |= SR_UX;
+    #endif
+  #endif
   mtpcr(sr0,PCR_SR);
 
   extern char trap_table;