From 5f20d75a5f9a3cbee6c855242458b33935310a58 Mon Sep 17 00:00:00 2001 From: Marcel Moolenaar Date: Wed, 6 Aug 2003 21:32:38 +0000 Subject: [PATCH] o In revision 1.45 of exception.S we changed exception_restore to unconditionally restore ar.k7 (kernel memory stack) and ar.k6 (kernel register stack). I don't know what I was smoking then, but if you unconditionally restore ar.k6, you also want to compute its value unconditionally. By having the computation predicated and dependent on whether we return to user mode, we would end up writing junk (= invalid value for ar.bspstore) if we would return to kernel mode. But the whole point of the unconditional restoration was that there is a grey area where we still need to have ar.k6 restored. If we restore with a junk value, we would end up wedging the machine on the next interrupt. So, unconditionally calculate the value we unconditionally write to ar.k6. o The previous braino was found while making the following change: We used to clear the lower 9 bits of the value we write to ar.k6. The meaning being that we know that the kernel register stack is at least 512 byte aligned and simply clearing the lower 9 bits allows us to return to a context of which we don't have dirty registers on the kernel stack, even though the context that entered the kernel does have dirty registers on the kernel stack. By masking-off the lower bits, we correctly obtain the base of the register stack without having to worry that we didn't actually reached the base while unwinding it. The change is to mask off the lower 13 bits, knowing that the kernel register stack is always 8KB aligned. The advantage is that we don't have to worry anymore if there's more than 512 bytes of dirty registers on the kernel stack. A situation that frequently occurs. In exec_setregs() in machdep.c:1.147 or older, we had to deal with that situation by copying the active portion of the register stack down in multiples of 512 bytes. Now that we mask off the lower 13 bits we don't have to do that at all. Contemporary IPF processors have a register file that can hold up to 96 stacked registers (=784 bytes [incl. 2 NaT collections]). With no indication that register files grow beyond a couple of hundred registers, we should not have to worry about it anymore... and yes, 640KB is enough for everybody :-) This change helps setcontext(2) and cpu_set_upcall_kse() in that they can return to completely different contexts without having to mess with the kernel stack. Of course exec_setregs() doesn't need to do that anymore as well. --- sys/ia64/ia64/exception.S | 4 ++-- sys/ia64/ia64/syscall.S | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/sys/ia64/ia64/exception.S b/sys/ia64/ia64/exception.S index a5cba96439a7..fbbf7b6a2149 100644 --- a/sys/ia64/ia64/exception.S +++ b/sys/ia64/ia64/exception.S @@ -535,10 +535,10 @@ exception_restore_restart: ;; } { .mmi -(p15) mov r31=ar.bspstore + mov r31=ar.bspstore ;; mov ar.bspstore=r20 -(p15) dep r31=0,r31,0,9 + dep r31=0,r31,0,13 // 8KB aligned ;; } { .mmb diff --git a/sys/ia64/ia64/syscall.S b/sys/ia64/ia64/syscall.S index f68002d19874..9a73ee4c3810 100644 --- a/sys/ia64/ia64/syscall.S +++ b/sys/ia64/ia64/syscall.S @@ -486,7 +486,7 @@ epc_syscall_return: mov r30=ar.bspstore ;; mov r14=ar.k5 - dep r30=0,r30,0,9 + dep r30=0,r30,0,13 // 8KB aligned. ;; } { .mmi @@ -518,7 +518,7 @@ epc_syscall_setup_ia32: mov r30=ar.bspstore ;; mov ar.unat=r17 - dep r30=0,r30,0,9 + dep r30=0,r30,0,13 // 8KB aligned ;; } { .mmi