Changeset 0af7a09 in mainline


Ignore:
Timestamp:
2006-12-21T08:02:01Z (17 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
b84ce45
Parents:
730376d
Message:

sparc64 work:

  • No need to lock kernel stack and userspace window buffer into DTLB.
Location:
kernel/arch/sparc64/src
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/sparc64/src/cpu/cpu.c

    r730376d r0af7a09  
    4141#include <arch/types.h>
    4242#include <arch/drivers/tick.h>
    43 #include <arch/mm/page.h>
    44 #include <arch/mm/tlb.h>
    45 #include <macros.h>
    4643
    4744/** Perform sparc64 specific initialization of the processor structure for the
    … …  
    8178        CPU->arch.clock_frequency = clock_frequency;
    8279        tick_init();
    83        
    84         /*
    85          * Lock CPU stack in DTLB.
    86          */
    87         uintptr_t base = ALIGN_DOWN(config.base, 1 << KERNEL_PAGE_WIDTH);
    88                  
    89         if (!overlaps((uintptr_t) CPU->stack, PAGE_SIZE, base, (1 <<
    90                 KERNEL_PAGE_WIDTH))) {
    91                 /*
    92                  * Kernel stack of this processor is not locked in DTLB.
    93                  * First, demap any already existing mappings.
    94                  * Second, create a locked mapping for it.
    95                  */
    96                 dtlb_demap(TLB_DEMAP_PAGE, TLB_DEMAP_NUCLEUS, (uintptr_t)
    97                         CPU->stack);
    98                 dtlb_insert_mapping((uintptr_t) CPU->stack, KA2PA(CPU->stack),
    99                         PAGESIZE_8K, true, true);
    100         }
    10180}
    10281

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

    r730376d r0af7a09  
    3737#include <arch.h>
    3838#include <arch/asm.h>
    39 #include <arch/regdef.h>
    4039#include <arch/stack.h>
    41 #include <arch/mm/tlb.h>
    42 #include <arch/mm/page.h>
    43 #include <config.h>
    44 #include <align.h>
    45 #include <macros.h>
    4640
    4741/** Perform sparc64 specific tasks needed before the new task is run. */
    … …  
    5246/** Perform sparc64 specific steps before scheduling a thread.
    5347 *
    54  * Ensure that thread's kernel stack, as well as userspace window buffer for
    55  * userspace threads, are locked in DTLB. For userspace threads, initialize
    56  * reserved global registers in the alternate and interrupt sets.
     48 * For userspace threads, initialize reserved global registers in the alternate
     49 * and interrupt sets.
    5750 */
    5851void before_thread_runs_arch(void)
    5952{
    60         uintptr_t base;
    61        
    62         base = ALIGN_DOWN(config.base, 1<<KERNEL_PAGE_WIDTH);
    63 
    64         if (!overlaps((uintptr_t) THREAD->kstack, PAGE_SIZE, base, (1 <<
    65                 KERNEL_PAGE_WIDTH))) {
    66                 /*
    67                  * Kernel stack of this thread is not locked in DTLB.
    68                  * First, make sure it is not mapped already.
    69                  * If not, create a locked mapping for it.
    70                  */
    71                 dtlb_demap(TLB_DEMAP_PAGE, TLB_DEMAP_NUCLEUS, (uintptr_t)
    72                         THREAD->kstack);
    73                 dtlb_insert_mapping((uintptr_t) THREAD->kstack,
    74                         KA2PA(THREAD->kstack), PAGESIZE_8K, true, true);
    75         }
    76        
    7753        if ((THREAD->flags & THREAD_FLAG_USPACE)) {
    78                 /*
    79                  * If this thread executes also in userspace, we have to lock
    80                  * its userspace window buffer into DTLB.
    81                  */
    82                 ASSERT(THREAD->arch.uspace_window_buffer);
    83                 uintptr_t uw_buf = ALIGN_DOWN((uintptr_t)
    84                         THREAD->arch.uspace_window_buffer, PAGE_SIZE);
    85                 if (!overlaps(uw_buf, PAGE_SIZE, base, 1 << KERNEL_PAGE_WIDTH))
    86                         {
    87                         /*
    88                          * The buffer is not covered by the 4M locked kernel
    89                          * DTLB entry.
    90                          */
    91                         dtlb_demap(TLB_DEMAP_PAGE, TLB_DEMAP_NUCLEUS, uw_buf);
    92                         dtlb_insert_mapping(uw_buf, KA2PA(uw_buf), PAGESIZE_8K,
    93                                 true, true);
    94                 }
    95                
    9654                /*
    9755                 * Write kernel stack address to %g6 of the alternate and
    … …  
    11472}
    11573
    116 /** Perform sparc64 specific steps before a thread stops running.
    117  *
    118  * Demap any locked DTLB entries installed by the thread (i.e. kernel stack
    119  * and userspace window buffer).
    120  */
     74/** Perform sparc64 specific steps before a thread stops running. */
    12175void after_thread_ran_arch(void)
    12276{
    123         uintptr_t base;
    124 
    125         base = ALIGN_DOWN(config.base, 1 << KERNEL_PAGE_WIDTH);
    126 
    127         if (!overlaps((uintptr_t) THREAD->kstack, PAGE_SIZE, base, (1 <<
    128                 KERNEL_PAGE_WIDTH))) {
    129                 /*
    130                  * Kernel stack of this thread is locked in DTLB.
    131                  * Destroy the mapping.
    132                  */
    133                 dtlb_demap(TLB_DEMAP_PAGE, TLB_DEMAP_NUCLEUS, (uintptr_t)
    134                         THREAD->kstack);
    135         }
    136        
    13777        if ((THREAD->flags & THREAD_FLAG_USPACE)) {
    138                 /*
    139                  * If this thread executes also in userspace, we have to
    140                  * demap the userspace window buffer from DTLB.
    141                  */
    142                 ASSERT(THREAD->arch.uspace_window_buffer);
    143                
    144                 uintptr_t uw_buf = ALIGN_DOWN((uintptr_t)
    145                         THREAD->arch.uspace_window_buffer, PAGE_SIZE);
    146                 if (!overlaps(uw_buf, PAGE_SIZE, base, 1 << KERNEL_PAGE_WIDTH)) {
    147                         /*
    148                          * The buffer is not covered by the 4M locked kernel DTLB entry
    149                          * and therefore it was given a dedicated locked DTLB entry.
    150                          * Demap it.
    151                          */
    152                         dtlb_demap(TLB_DEMAP_PAGE, TLB_DEMAP_NUCLEUS, uw_buf);
    153                 }
    154        
    15578                /* sample the state of the userspace window buffer */   
    15679                THREAD->arch.uspace_window_buffer = (uint8_t *) read_from_ag_g7();

  • kernel/arch/sparc64/src/trap/trap_table.S

    r730376d r0af7a09  
    743743        rd %y, %g4
    744744
    745         /*
    746          * The following memory accesses will not fault
    747          * because special provisions are made to have
    748          * the kernel stack of THREAD locked in DTLB.
    749          */
    750745        stx %g1, [%sp + PREEMPTIBLE_HANDLER_STACK_FRAME_SIZE + STACK_BIAS + SAVED_TSTATE]
    751746        stx %g2, [%sp + PREEMPTIBLE_HANDLER_STACK_FRAME_SIZE + STACK_BIAS + SAVED_TPC]
Note: See TracChangeset for help on using the changeset viewer.