cvs commit: src/sys/ia64/ia64 exception.S syscall.S

[Marcel Moolenaar]

marcel      2003/08/06 14:32:38 PDT

  FreeBSD src repository

  Modified files:
    sys/ia64/ia64        exception.S syscall.S 
  Log:
  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.
  
  Revision  Changes    Path
  1.51      +2 -2      src/sys/ia64/ia64/exception.S
  1.6       +2 -2      src/sys/ia64/ia64/syscall.S