Changeset 0fa6044 in mainline for kernel/arch/sparc64/src/proc/scheduler.c

Timestamp:

2006-08-29T15:35:44Z (19 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

e11ae91

Parents:

32fffef0

Message:

sparc64 work.

Fix bug introduced in revision 1852. When fixing CWP,
the input registers of the current window (i.e. output
registers of the window belonging to the interrupted
context) must be preserved. Preserve those registers
in memory. Sure there exist more efficient ways how to
copy the inputs.

Simplify before_thread_runs_arch(), resp. after_thread_ran_arch(),
and make them install, resp. uninstall, DTLB locked mapping for
eventual userspace window buffer.

File:

• kernel/arch/sparc64/src/proc/scheduler.c (modified) (6 diffs)

kernel/arch/sparc64/src/proc/scheduler.c

@@ -36 +36 @@
 #include <proc/thread.h>
 #include <arch.h>
+#include <arch/asm.h>
 #include <arch/mm/tlb.h>
 #include <arch/mm/page.h>
 #include <config.h>
 #include <align.h>
+#include <macros.h>
 
 /** Perform sparc64 specific tasks needed before the new task is run. */
@@ -46 +48 @@
 }
 
-/** Ensure that thread's kernel stack is locked in TLB. */
+/** Perform sparc64 specific steps before scheduling a thread.
+ *
+ * Ensure that thread's kernel stack, as well as userspace window
+ * buffer for userspace threads, are locked in DTLB.
+ */
 void before_thread_runs_arch(void)
 {
@@ -53 +59 @@
         base = ALIGN_DOWN(config.base, 1<<KERNEL_PAGE_WIDTH);
 
-        if ((uintptr_t) THREAD->kstack < base || (uintptr_t) THREAD->kstack > base + (1<<KERNEL_PAGE_WIDTH)) {
+        if (!overlaps((uintptr_t) THREAD->kstack, PAGE_SIZE, base, (1<<KERNEL_PAGE_WIDTH))) {
                 /*
                  * Kernel stack of this thread is not locked in DTLB.
@@ -59 +65 @@
                  * If not, create a locked mapping for it.
                  */
-                 dtlb_demap(TLB_DEMAP_PAGE, TLB_DEMAP_NUCLEUS, (uintptr_t) THREAD->kstack);
-                 dtlb_insert_mapping((uintptr_t) THREAD->kstack, KA2PA(THREAD->kstack), PAGESIZE_8K, true, true);
-        }       
+                dtlb_demap(TLB_DEMAP_PAGE, TLB_DEMAP_NUCLEUS, (uintptr_t) THREAD->kstack);
+                dtlb_insert_mapping((uintptr_t) THREAD->kstack, KA2PA(THREAD->kstack), PAGESIZE_8K, true, true);
+        }
+        
+        if ((THREAD->flags & THREAD_FLAG_USPACE)) {
+                /*
+                 * If this thread executes also in userspace, we have to lock
+                 * its userspace window buffer into DTLB.
+                 */
+                ASSERT(THREAD->arch.uspace_window_buffer);
+                uintptr_t uw_buf = (uintptr_t) THREAD->arch.uspace_window_buffer;
+                if (!overlaps(uw_buf, PAGE_SIZE, base, 1<<KERNEL_PAGE_WIDTH)) {
+                        /*
+                         * The buffer is not covered by the 4M locked kernel DTLB entry.
+                         */
+                        dtlb_demap(TLB_DEMAP_PAGE, TLB_DEMAP_NUCLEUS, (uintptr_t) uw_buf);
+                        dtlb_insert_mapping(uw_buf, KA2PA(uw_buf), PAGESIZE_8K, true, true);
+                }
+        }
 }
 
-/** Unlock thread's stack from TLB, if necessary. */
+/** Perform sparc64 specific steps before a thread stops running.
+ *
+ * Demap any locked DTLB entries isntalled by the thread (i.e. kernel stack
+ * and userspace window buffer).
+ */
 void after_thread_ran_arch(void)
 {
@@ -71 +97 @@
         base = ALIGN_DOWN(config.base, 1<<KERNEL_PAGE_WIDTH);
 
-        if ((uintptr_t) THREAD->kstack < base || (uintptr_t) THREAD->kstack > base + (1<<KERNEL_PAGE_WIDTH)) {
+        if (!overlaps((uintptr_t) THREAD->kstack, PAGE_SIZE, base, (1<<KERNEL_PAGE_WIDTH))) {
                 /*
                  * Kernel stack of this thread is locked in DTLB.
@@ -78 +104 @@
                 dtlb_demap(TLB_DEMAP_PAGE, TLB_DEMAP_NUCLEUS, (uintptr_t) THREAD->kstack);
         }
+        
+        if ((THREAD->flags & THREAD_FLAG_USPACE)) {
+                /*
+                 * If this thread executes also in userspace, we have to force all
+                 * its still-active userspace windows into the userspace window buffer
+                 * and demap the buffer from DTLB.
+                 */
+                ASSERT(THREAD->arch.uspace_window_buffer);
+                
+                flushw();       /* force all userspace windows into memory */
+                
+                uintptr_t uw_buf = (uintptr_t) THREAD->arch.uspace_window_buffer;
+                if (!overlaps(uw_buf, PAGE_SIZE, base, 1<<KERNEL_PAGE_WIDTH)) {
+                        /*
+                         * The buffer is not covered by the 4M locked kernel DTLB entry
+                         * and therefore it was given a dedicated locked DTLB entry.
+                         * Demap it.
+                         */
+                        dtlb_demap(TLB_DEMAP_PAGE, TLB_DEMAP_NUCLEUS, (uintptr_t) uw_buf);
+                }
+        }
 }