Changeset ef9a2a8 in mainline


Ignore:
Timestamp:
2013-09-15T19:23:19Z (11 years ago)
Author:
Jakub Klama <jakub.klama@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
3efc35a
Parents:
b6b02c0
Message:

Introduce early MMU support in kernel. At current state, it
is possible to create initial kernel address space, map kernel
identity into it and take over MMU control. ASID FIFO support
should also work.

Files:
18 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    rb6b02c0 ref9a2a8  
    363363
    364364% ASID support
    365 ! [PLATFORM=ia64|PLATFORM=mips32|PLATFORM=mips64|PLATFORM=ppc32|PLATFORM=sparc64] CONFIG_ASID (y)
     365! [PLATFORM=ia64|PLATFORM=mips32|PLATFORM=mips64|PLATFORM=ppc32|PLATFORM=sparc64|PLATFORM=sparc32] CONFIG_ASID (y)
    366366
    367367% ASID FIFO support
    368 ! [PLATFORM=ia64|PLATFORM=mips32|PLATFORM=mips64|PLATFORM=ppc32|PLATFORM=sparc64] CONFIG_ASID_FIFO (y)
     368! [PLATFORM=ia64|PLATFORM=mips32|PLATFORM=mips64|PLATFORM=ppc32|PLATFORM=sparc64|PLATFORM=sparc32] CONFIG_ASID_FIFO (y)
    369369
    370370% OpenFirmware tree support

  • boot/arch/sparc32/include/asm.h

    rb6b02c0 ref9a2a8  
    5757}
    5858
    59 extern void jump_to_kernel(void *entry);
     59extern void jump_to_kernel(void *entry, bootinfo_t *bootinfo);
    6060
    6161#endif

  • boot/arch/sparc32/src/asm.S

    rb6b02c0 ref9a2a8  
    5353jump_to_kernel:
    5454        set 0x80a00000, %l0
     55       
    5556        jmp %l0
    5657        nop

  • boot/arch/sparc32/src/main.c

    rb6b02c0 ref9a2a8  
    120120
    121121        printf("Booting the kernel ... \n");
    122         jump_to_kernel((void *) PA2KA(BOOT_OFFSET));
     122        jump_to_kernel((void *) PA2KA(BOOT_OFFSET), &bootinfo);
    123123}
    124124

  • kernel/arch/sparc32/include/arch/arch.h

    rb6b02c0 ref9a2a8  
    11/*
    22 * Copyright (c) 2010 Martin Decky
     3 * Copyright (c) 2013 Jakub Klama
    34 * All rights reserved.
    45 *
    … …  
    3839#ifndef __ASM__
    3940
    40 void arch_pre_main(void);
     41#include <typedefs.h>
     42
     43/* ASI assignments: */
     44#define ASI_CACHEMISS   0x01
     45#define ASI_CACHECTRL   0x02
     46#define ASI_MMUREGS     0x19
     47#define ASI_MMUBYPASS   0x1c
     48
     49#define TASKMAP_MAX_RECORDS  32
     50#define CPUMAP_MAX_RECORDS   32
     51
     52#define BOOTINFO_TASK_NAME_BUFLEN 32
     53
     54typedef struct {
     55        void *addr;
     56        size_t size;
     57        char name[BOOTINFO_TASK_NAME_BUFLEN];
     58} utask_t;
     59
     60typedef struct {
     61        size_t cnt;
     62        utask_t tasks[TASKMAP_MAX_RECORDS];
     63} bootinfo_t;
     64
     65void arch_pre_main(bootinfo_t *bootinfo);
    4166
    4267#endif

  • kernel/arch/sparc32/include/arch/asm.h

    rb6b02c0 ref9a2a8  
    142142}
    143143
     144NO_TRACE static inline uint32_t asi_u32_read(int asi, uintptr_t va)
     145{
     146        uint32_t v;
     147
     148        asm volatile (
     149                "lda [%[va]] %[asi], %[v]\n"
     150                : [v] "=r" (v)
     151                : [va] "r" (va),
     152                  [asi] "i" ((unsigned int) asi)
     153        );
     154       
     155        return v;
     156}
     157
     158NO_TRACE static inline void asi_u32_write(int asi, uintptr_t va, uint32_t v)
     159{
     160        asm volatile (
     161                "sta %[v], [%[va]] %[asi]\n"
     162                :: [v] "r" (v),
     163                   [va] "r" (va),
     164                   [asi] "i" ((unsigned int) asi)
     165                : "memory"
     166        );
     167}
     168
    144169NO_TRACE static inline void psr_write(uint32_t psr)
    145170{

  • kernel/arch/sparc32/include/arch/mm/as.h

    rb6b02c0 ref9a2a8  
    11/*
    22 * Copyright (c) 2010 Martin Decky
     3 * Copyright (c) 2013 Jakub Klama
    34 * All rights reserved.
    45 *
    … …  
    2728 */
    2829
    29 /** @addtogroup abs32lemm
     30/** @addtogroup sparc32mm
    3031 * @{
    3132 */
    … …  
    3334 */
    3435
    35 #ifndef KERN_abs32le_AS_H_
    36 #define KERN_abs32le_AS_H_
     36#ifndef KERN_sparc32_AS_H_
     37#define KERN_sparc32_AS_H_
    3738
    3839#define KERNEL_ADDRESS_SPACE_SHADOWED_ARCH  0
    … …  
    5152#define as_destructor_arch(as)          (as != as)
    5253#define as_create_arch(as, flags)       (as != as)
    53 #define as_install_arch(as)
    5454#define as_deinstall_arch(as)
    5555#define as_invalidate_translation_cache(as, page, cnt)
     56
     57uintptr_t as_context_table;
    5658
    5759extern void as_arch_init(void);

  • kernel/arch/sparc32/include/arch/mm/asid.h

    rb6b02c0 ref9a2a8  
    2727 */
    2828
    29 /** @addtogroup abc32lemm
     29/** @addtogroup sparc32mm
    3030 * @{
    3131 */
    3232
    33 #ifndef KERN_abs32le_ASID_H_
    34 #define KERN_abs32le_ASID_H_
     33#ifndef KERN_sparc32_ASID_H_
     34#define KERN_sparc32_ASID_H_
    3535
    3636#include <typedefs.h>
    … …  
    3838typedef uint32_t asid_t;
    3939
    40 #define ASID_MAX_ARCH  3
    41 
    42 #define asid_get()      (ASID_START + 1)
    43 #define asid_put(asid)
     40#define ASID_MAX_ARCH  255
    4441
    4542#endif

  • kernel/arch/sparc32/include/arch/mm/frame.h

    rb6b02c0 ref9a2a8  
    4141#include <typedefs.h>
    4242
     43#define PHYSMEM_START_ADDR      0x40000000
     44
    4345#define BOOT_PT_ADDRESS         0x40008000
    4446#define BOOT_PT_START_FRAME     (BOOT_PT_ADDRESS >> FRAME_WIDTH)

  • kernel/arch/sparc32/include/arch/mm/page.h

    rb6b02c0 ref9a2a8  
    11/*
    22 * Copyright (c) 2010 Martin Decky
     3 * Copyright (c) 2013 Jakub Klama
    34 * All rights reserved.
    45 *
    … …  
    2728 */
    2829
    29 /** @addtogroup abs32lemm
     30/** @addtogroup sparc32mm
    3031 * @{
    3132 */
    … …  
    3334 */
    3435
    35 #ifndef KERN_abs32le_PAGE_H_
    36 #define KERN_abs32le_PAGE_H_
     36#ifndef KERN_sparc32_PAGE_H_
     37#define KERN_sparc32_PAGE_H_
    3738
    3839#include <arch/mm/frame.h>
    … …  
    4546#define PA2KA(x)  (((uintptr_t) (x)) + UINT32_C(0x40000000))
    4647
    47 /*
    48  * This is an example of 2-level page tables (PTL1 and PTL2 are left out)
    49  * on top of the generic 4-level page table interface.
    50  */
     48#define PTE_ET_INVALID          0
     49#define PTE_ET_DESCRIPTOR       1
     50#define PTE_ET_ENTRY            2
     51
     52#define PTE_ACC_USER_RO_KERNEL_RO       0
     53#define PTE_ACC_USER_RW_KERNEL_RW       1
     54#define PTE_ACC_USER_RX_KERNEL_RX       2
     55#define PTE_ACC_USER_RWX_KERNEL_RWX     3
     56#define PTE_ACC_USER_XO_KERNEL_XO       4
     57#define PTE_ACC_USER_RO_KERNEL_RW       5
     58#define PTE_ACC_USER_NO_KERNEL_RX       6
     59#define PTE_ACC_USER_NO_KERNEL_RWX      7
    5160
    5261/* Number of entries in each level. */
    53 #define PTL0_ENTRIES_ARCH  1024
     62#define PTL0_ENTRIES_ARCH  256
    5463#define PTL1_ENTRIES_ARCH  0
    55 #define PTL2_ENTRIES_ARCH  0
    56 #define PTL3_ENTRIES_ARCH  1024
     64#define PTL2_ENTRIES_ARCH  64
     65#define PTL3_ENTRIES_ARCH  64
    5766
    5867/* Page table sizes for each level. */
    5968#define PTL0_SIZE_ARCH  ONE_FRAME
    6069#define PTL1_SIZE_ARCH  0
    61 #define PTL2_SIZE_ARCH  0
     70#define PTL2_SIZE_ARCH  ONE_FRAME
    6271#define PTL3_SIZE_ARCH  ONE_FRAME
    6372
    6473/* Macros calculating indices for each level. */
    65 #define PTL0_INDEX_ARCH(vaddr)  (((vaddr) >> 22) & 0x3ffU)
     74#define PTL0_INDEX_ARCH(vaddr)  (((vaddr) >> 24) & 0xffU)
    6675#define PTL1_INDEX_ARCH(vaddr)  0
    67 #define PTL2_INDEX_ARCH(vaddr)  0
    68 #define PTL3_INDEX_ARCH(vaddr)  (((vaddr) >> 12) & 0x3ffU)
     76#define PTL2_INDEX_ARCH(vaddr)  (((vaddr) >> 18) & 0x3fU)
     77#define PTL3_INDEX_ARCH(vaddr)  (((vaddr) >> 12) & 0x3fU)
    6978
    7079/* Get PTE address accessors for each level. */
    … …  
    7281        ((pte_t *) ((((pte_t *) (ptl0))[(i)].frame_address) << 12))
    7382#define GET_PTL2_ADDRESS_ARCH(ptl1, i) \
    74         (ptl1)
     83        KA2PA(ptl1)
    7584#define GET_PTL3_ADDRESS_ARCH(ptl2, i) \
    76         (ptl2)
     85        ((pte_t *) ((((pte_t *) (ptl2))[(i)].frame_address) << 12))
    7786#define GET_FRAME_ADDRESS_ARCH(ptl3, i) \
    7887        ((uintptr_t) ((((pte_t *) (ptl3))[(i)].frame_address) << 12))
    … …  
    8392        (((pte_t *) (ptl0))[(i)].frame_address = (a) >> 12)
    8493#define SET_PTL2_ADDRESS_ARCH(ptl1, i, a)
    85 #define SET_PTL3_ADDRESS_ARCH(ptl2, i, a)
     94#define SET_PTL3_ADDRESS_ARCH(ptl2, i, a) \
     95        (((pte_t *) (ptl2))[(i)].frame_address = (a) >> 12)
    8696#define SET_FRAME_ADDRESS_ARCH(ptl3, i, a) \
    8797        (((pte_t *) (ptl3))[(i)].frame_address = (a) >> 12)
    … …  
    93103        PAGE_PRESENT
    94104#define GET_PTL3_FLAGS_ARCH(ptl2, i) \
    95         PAGE_PRESENT
     105        get_pt_flags((pte_t *) (ptl2), (size_t) (i))
    96106#define GET_FRAME_FLAGS_ARCH(ptl3, i) \
    97107        get_pt_flags((pte_t *) (ptl3), (size_t) (i))
    98108
    99109/* Set PTE flags accessors for each level. */
    100 #define SET_PTL1_FLAGS_ARCH(ptl0, i, x) \
    101         set_pt_flags((pte_t *) (ptl0), (size_t) (i), (x))
     110#define SET_PTL1_FLAGS_ARCH(ptl0, i, x)
    102111#define SET_PTL2_FLAGS_ARCH(ptl1, i, x)
    103112#define SET_PTL3_FLAGS_ARCH(ptl2, i, x)
    104113#define SET_FRAME_FLAGS_ARCH(ptl3, i, x) \
    105         set_pt_flags((pte_t *) (ptl3), (size_t) (i), (x))
     114        set_pte_flags((pte_t *) (ptl3), (size_t) (i), (x))
    106115
    107116/* Set PTE present bit accessors for each level. */
    108117#define SET_PTL1_PRESENT_ARCH(ptl0, i)  \
    109         set_pt_present((pte_t *) (ptl0), (size_t) (i))
     118        set_ptd_present((pte_t *) (ptl0), (size_t) (i))
    110119#define SET_PTL2_PRESENT_ARCH(ptl1, i)
    111 #define SET_PTL3_PRESENT_ARCH(ptl2, i)
     120#define SET_PTL3_PRESENT_ARCH(ptl2, i) \
     121        set_ptd_present((pte_t *) (ptl2), (size_t) (i))
    112122#define SET_FRAME_PRESENT_ARCH(ptl3, i) \
    113         set_pt_present((pte_t *) (ptl3), (size_t) (i))
     123        set_pte_present((pte_t *) (ptl3), (size_t) (i))
    114124
    115125/* Macros for querying the last level entries. */
    … …  
    117127        (*((uint32_t *) (p)) != 0)
    118128#define PTE_PRESENT_ARCH(p) \
    119         ((p)->present != 0)
     129        ((p)->et != 0)
    120130#define PTE_GET_FRAME_ARCH(p) \
    121131        ((p)->frame_address << FRAME_WIDTH)
    122132#define PTE_WRITABLE_ARCH(p) \
    123         ((p)->writeable != 0)
    124 #define PTE_EXECUTABLE_ARCH(p)  1
     133        pte_is_writeable(p)
     134#define PTE_EXECUTABLE_ARCH(p) \
     135        pte_is_executable(p)
    125136
    126137#include <mm/mm.h>
    … …  
    128139#include <typedefs.h>
    129140
     141/** Page Table Descriptor. */
     142typedef struct {
     143        unsigned int table_pointer: 30;
     144        unsigned int et: 2;
     145} __attribute__((packed)) ptd_t;
     146
    130147/** Page Table Entry. */
    131148typedef struct {
    132         unsigned int present : 1;
    133         unsigned int writeable : 1;
    134         unsigned int uaccessible : 1;
    135         unsigned int page_write_through : 1;
    136         unsigned int page_cache_disable : 1;
    137         unsigned int accessed : 1;
    138         unsigned int dirty : 1;
    139         unsigned int pat : 1;
    140         unsigned int global : 1;
     149        unsigned int frame_address: 24;
     150        unsigned int cacheable: 1;
     151        unsigned int modified: 1;
     152        unsigned int referenced: 1;
     153        unsigned int acc: 3;
     154        unsigned int et: 2;
     155} __attribute__((packed)) pte_t;
     156
     157NO_TRACE static inline void set_ptl0_addr(pte_t *pt)
     158{
     159}
     160
     161NO_TRACE static inline bool pte_is_writeable(pte_t *pt)
     162{
     163        return (
     164                pt->acc == PTE_ACC_USER_RW_KERNEL_RW ||
     165                pt->acc == PTE_ACC_USER_RWX_KERNEL_RWX ||
     166                pt->acc == PTE_ACC_USER_RO_KERNEL_RW ||
     167                pt->acc == PTE_ACC_USER_NO_KERNEL_RWX
     168        );
     169}
     170
     171NO_TRACE static inline bool pte_is_executable(pte_t *pt)
     172{
     173        return (
     174                pt->acc != PTE_ACC_USER_RO_KERNEL_RO &&
     175                pt->acc != PTE_ACC_USER_RW_KERNEL_RW &&
     176                pt->acc != PTE_ACC_USER_RO_KERNEL_RW
     177        );
     178}
     179
     180NO_TRACE static inline unsigned int get_pt_flags(pte_t *pt, size_t i)
     181    REQUIRES_ARRAY_MUTABLE(pt, PTL0_ENTRIES_ARCH)
     182{
     183        pte_t *p = &pt[i];
     184
     185        bool notpresent = p->et == 0;
     186
     187        return (
     188                (p->cacheable << PAGE_CACHEABLE_SHIFT) |
     189                (notpresent << PAGE_PRESENT_SHIFT) |
     190                ((p->acc != PTE_ACC_USER_NO_KERNEL_RX && p->acc != PTE_ACC_USER_NO_KERNEL_RWX) << PAGE_USER_SHIFT) |
     191                (1 << PAGE_READ_SHIFT) |
     192                ((
     193                        p->acc == PTE_ACC_USER_RW_KERNEL_RW ||
     194                        p->acc == PTE_ACC_USER_RWX_KERNEL_RWX ||
     195                        p->acc == PTE_ACC_USER_RO_KERNEL_RW ||
     196                        p->acc == PTE_ACC_USER_NO_KERNEL_RWX
     197                ) << PAGE_WRITE_SHIFT) |
     198                ((
     199                        p->acc != PTE_ACC_USER_RO_KERNEL_RO &&
     200                        p->acc != PTE_ACC_USER_RW_KERNEL_RW &&
     201                        p->acc != PTE_ACC_USER_RO_KERNEL_RW
     202                ) << PAGE_EXEC_SHIFT) |
     203                (1 << PAGE_GLOBAL_SHIFT)
     204        );
     205}
     206
     207NO_TRACE static inline void set_ptd_flags(pte_t *pt, size_t i, int flags)
     208    WRITES(ARRAY_RANGE(pt, PTL0_ENTRIES_ARCH))
     209    REQUIRES_ARRAY_MUTABLE(pt, PTL0_ENTRIES_ARCH)
     210{
     211        pte_t *p = &pt[i];
    141212       
    142         /** Valid content even if the present bit is not set. */
    143         unsigned int soft_valid : 1;
    144         unsigned int avl : 2;
    145         unsigned int frame_address : 20;
    146 } __attribute__((packed)) pte_t;
    147 
    148 NO_TRACE static inline unsigned int get_pt_flags(pte_t *pt, size_t i)
    149     REQUIRES_ARRAY_MUTABLE(pt, PTL0_ENTRIES_ARCH)
    150 {
    151         pte_t *p = &pt[i];
     213        p->et = (flags & PAGE_NOT_PRESENT)
     214                ? PTE_ET_INVALID
     215                : PTE_ET_DESCRIPTOR;
     216}
     217
     218NO_TRACE static inline void set_pte_flags(pte_t *pt, size_t i, int flags)
     219    WRITES(ARRAY_RANGE(pt, PTL0_ENTRIES_ARCH))
     220    REQUIRES_ARRAY_MUTABLE(pt, PTL0_ENTRIES_ARCH)
     221{
     222        pte_t *p = &pt[i];
     223
     224        p->et = PTE_ET_ENTRY;
     225        p->acc = PTE_ACC_USER_NO_KERNEL_RWX;
    152226       
    153         return (
    154             ((unsigned int) (!p->page_cache_disable) << PAGE_CACHEABLE_SHIFT) |
    155             ((unsigned int) (!p->present) << PAGE_PRESENT_SHIFT) |
    156             ((unsigned int) p->uaccessible << PAGE_USER_SHIFT) |
    157             (1 << PAGE_READ_SHIFT) |
    158             ((unsigned int) p->writeable << PAGE_WRITE_SHIFT) |
    159             (1 << PAGE_EXEC_SHIFT) |
    160             ((unsigned int) p->global << PAGE_GLOBAL_SHIFT)
    161         );
    162 }
    163 
    164 NO_TRACE static inline void set_pt_flags(pte_t *pt, size_t i, int flags)
    165     WRITES(ARRAY_RANGE(pt, PTL0_ENTRIES_ARCH))
    166     REQUIRES_ARRAY_MUTABLE(pt, PTL0_ENTRIES_ARCH)
    167 {
    168         pte_t *p = &pt[i];
    169        
    170         p->page_cache_disable = !(flags & PAGE_CACHEABLE);
    171         p->present = !(flags & PAGE_NOT_PRESENT);
    172         p->uaccessible = (flags & PAGE_USER) != 0;
    173         p->writeable = (flags & PAGE_WRITE) != 0;
    174         p->global = (flags & PAGE_GLOBAL) != 0;
    175        
    176         /*
    177          * Ensure that there is at least one bit set even if the present bit is
    178          * cleared.
    179          */
    180         p->soft_valid = true;
    181 }
    182 
    183 NO_TRACE static inline void set_pt_present(pte_t *pt, size_t i)
    184     WRITES(ARRAY_RANGE(pt, PTL0_ENTRIES_ARCH))
    185     REQUIRES_ARRAY_MUTABLE(pt, PTL0_ENTRIES_ARCH)
    186 {
    187         pte_t *p = &pt[i];
    188 
    189         p->present = 1;
     227        if (flags & PAGE_USER) {
     228                if (flags & PAGE_READ)
     229                        p->acc = PTE_ACC_USER_RO_KERNEL_RW;
     230                if (flags & PAGE_WRITE)
     231                        p->acc = PTE_ACC_USER_RW_KERNEL_RW;
     232        }
     233
     234        if (flags & PAGE_NOT_PRESENT)
     235                p->et = PTE_ET_INVALID;
     236
     237        p->cacheable = (flags & PAGE_CACHEABLE) != 0;
     238}
     239
     240NO_TRACE static inline void set_ptd_present(pte_t *pt, size_t i)
     241    WRITES(ARRAY_RANGE(pt, PTL0_ENTRIES_ARCH))
     242    REQUIRES_ARRAY_MUTABLE(pt, PTL0_ENTRIES_ARCH)
     243{
     244        pte_t *p = &pt[i];
     245
     246        p->et = PTE_ET_DESCRIPTOR;
     247}
     248
     249NO_TRACE static inline void set_pte_present(pte_t *pt, size_t i)
     250    WRITES(ARRAY_RANGE(pt, PTL0_ENTRIES_ARCH))
     251    REQUIRES_ARRAY_MUTABLE(pt, PTL0_ENTRIES_ARCH)
     252{
     253        pte_t *p = &pt[i];
     254
     255        p->et = PTE_ET_ENTRY;
    190256}
    191257

  • kernel/arch/sparc32/src/mm/as.c

    rb6b02c0 ref9a2a8  
    11/*
    2  * Copyright (c) 2010 Martin Decky
     2 * Copyright (c) 2013 Jakub Klama
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup abs32lemm
     29/** @addtogroup sparc32mm
    3030 * @{
    3131 */
    3232
    3333#include <mm/as.h>
     34#include <arch/arch.h>
     35#include <arch/asm.h>
    3436#include <arch/mm/as.h>
     37#include <arch/mm/page.h>
    3538#include <genarch/mm/page_pt.h>
     39
     40static ptd_t context_table[ASID_MAX_ARCH] __attribute__((aligned (1024)));
    3641
    3742void as_arch_init(void)
    3843{
    3944        as_operations = &as_pt_operations;
     45        as_context_table = (uintptr_t)&context_table;
     46}
     47
     48void as_install_arch(as_t *as)
     49{
     50        printf("as_install_arch(asid=%d)\n", as->asid);
     51        printf("genarch.page_table=%p\n", as->genarch.page_table);
     52
     53        context_table[as->asid].table_pointer = (uintptr_t)as->genarch.page_table >> 6;
     54        context_table[as->asid].et = PTE_ET_DESCRIPTOR;
     55        asi_u32_write(ASI_MMUREGS, 0x200, as->asid);
    4056}
    4157

  • kernel/arch/sparc32/src/mm/frame.c

    rb6b02c0 ref9a2a8  
    4848        //machine_get_memory_extents(&base, &size);
    4949        base = 0x40000000;
    50         size = 0x2000000;
     50        size = 0x4000000;
    5151
    5252        base = ALIGN_UP(base, FRAME_SIZE);

  • kernel/arch/sparc32/src/mm/page.c

    rb6b02c0 ref9a2a8  
    4949#include <print.h>
    5050#include <interrupt.h>
     51#include <macros.h>
    5152
    5253void page_arch_init(void)
    5354{
    54         if (config.cpu_active == 1)
    55                 page_mapping_operations = &pt_mapping_operations;
     55        int flags = PAGE_CACHEABLE | PAGE_EXEC;
     56        page_mapping_operations = &pt_mapping_operations;
     57
     58        page_table_lock(AS_KERNEL, true);
     59       
     60        /* Kernel identity mapping */
     61        //FIXME: We need to consider the possibility that
     62        //identity_base > identity_size and physmem_end.
     63        //This might lead to overflow if identity_size is too big.
     64        for (uintptr_t cur = PHYSMEM_START_ADDR;
     65            cur < min(KA2PA(config.identity_base) +
     66                config.identity_size, config.physmem_end);
     67            cur += FRAME_SIZE)
     68                page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
     69       
     70
     71        page_table_unlock(AS_KERNEL, true);
     72        as_switch(NULL, AS_KERNEL);
     73
     74        printf("as_context_table=0x%08x\n", as_context_table);
     75
     76        /* Switch MMU to new context table */
     77        asi_u32_write(ASI_MMUREGS, 0x100, KA2PA(as_context_table) >> 4);
     78
     79        //boot_page_table_free();
    5680}
    5781

  • kernel/arch/sparc32/src/sparc32.c

    rb6b02c0 ref9a2a8  
    4949#include <syscall/syscall.h>
    5050#include <console/console.h>
     51#include <macros.h>
    5152#include <memstr.h>
     53#include <str.h>
    5254
    5355char memcpy_from_uspace_failover_address;
    5456char memcpy_to_uspace_failover_address;
    5557
    56 void arch_pre_main(void)
     58void arch_pre_main(bootinfo_t *bootinfo)
    5759{
     60        init.cnt = min3(bootinfo->cnt, TASKMAP_MAX_RECORDS, CONFIG_INIT_TASKS);
     61       
     62        size_t i;
     63        for (i = 0; i < init.cnt; i++) {
     64                init.tasks[i].paddr = KA2PA(bootinfo->tasks[i].addr);
     65                init.tasks[i].size = bootinfo->tasks[i].size;
     66                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN,
     67                    bootinfo->tasks[i].name);
     68        }
    5869}
    5970

  • kernel/arch/sparc32/src/start.S

    rb6b02c0 ref9a2a8  
    5151        sub     %sp, 96, %sp
    5252
     53        mov     %o1, %i0
    5354        call arch_pre_main
    5455        nop

  • kernel/genarch/src/mm/page_pt.c

    rb6b02c0 ref9a2a8  
    7777    unsigned int flags)
    7878{
     79        //printf("pt_mapping_insert: as=%p, page=0x%08x, frame=0x%08x\n", as, page, frame);
     80
    7981        pte_t *ptl0 = (pte_t *) PA2KA((uintptr_t) as->genarch.page_table);
    8082
     83        //printf("ptl0 = %p\n", ptl0);
     84
    8185        ASSERT(page_table_locked(as));
    82        
     86
    8387        if (GET_PTL1_FLAGS(ptl0, PTL0_INDEX(page)) & PAGE_NOT_PRESENT) {
     88        //      printf("allocating ptl1\n");
     89
    8490                pte_t *newpt = (pte_t *) frame_alloc(PTL1_SIZE,
    8591                    FRAME_LOWMEM | FRAME_KA);
     92
     93        //      printf("newpt = %p, index = %d\n", newpt, PTL0_INDEX(page));
     94
    8695                memsetb(newpt, FRAME_SIZE << PTL1_SIZE, 0);
    8796                SET_PTL1_ADDRESS(ptl0, PTL0_INDEX(page), KA2PA(newpt));
    … …  
    100109        pte_t *ptl1 = (pte_t *) PA2KA(GET_PTL1_ADDRESS(ptl0, PTL0_INDEX(page)));
    101110       
     111//      printf("ptl1 = %p\n", ptl1);
     112
    102113        if (GET_PTL2_FLAGS(ptl1, PTL1_INDEX(page)) & PAGE_NOT_PRESENT) {
     114//              printf("allocating ptl2\n");
     115
    103116                pte_t *newpt = (pte_t *) frame_alloc(PTL2_SIZE,
    104117                    FRAME_LOWMEM | FRAME_KA);
     118
     119//              printf("newpt = %p, index = %d\n", newpt, PTL1_INDEX(page));
     120
    105121                memsetb(newpt, FRAME_SIZE << PTL2_SIZE, 0);
    106122                SET_PTL2_ADDRESS(ptl1, PTL1_INDEX(page), KA2PA(newpt));
    … …  
    117133        pte_t *ptl2 = (pte_t *) PA2KA(GET_PTL2_ADDRESS(ptl1, PTL1_INDEX(page)));
    118134       
     135//      printf("ptl2 = %p\n", ptl2);
     136
    119137        if (GET_PTL3_FLAGS(ptl2, PTL2_INDEX(page)) & PAGE_NOT_PRESENT) {
     138//              printf("allocating ptl3\n");
     139
    120140                pte_t *newpt = (pte_t *) frame_alloc(PTL3_SIZE,
    121141                    FRAME_LOWMEM | FRAME_KA);
     142
     143//              printf("newpt = %p, index = %d\n", newpt, PTL2_INDEX(page));
     144
    122145                memsetb(newpt, FRAME_SIZE << PTL3_SIZE, 0);
    123146                SET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page), KA2PA(newpt));
    … …  
    134157        pte_t *ptl3 = (pte_t *) PA2KA(GET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page)));
    135158       
     159//      printf("ptl3 = %p\n", ptl3);
     160
    136161        SET_FRAME_ADDRESS(ptl3, PTL3_INDEX(page), frame);
    137162        SET_FRAME_FLAGS(ptl3, PTL3_INDEX(page), flags | PAGE_NOT_PRESENT);

  • kernel/generic/src/proc/scheduler.c

    rb6b02c0 ref9a2a8  
    6464#include <stacktrace.h>
    6565
     66//#define       SCHEDULER_VERBOSE 1
     67
    6668static void scheduler_separated_stack(void);
    6769
    … …  
    518520#ifdef SCHEDULER_VERBOSE
    519521        printf("cpu%u: tid %" PRIu64 " (priority=%d, ticks=%" PRIu64
    520             ", nrdy=%ld)\n", CPU->id, THREAD->tid, THREAD->priority,
     522            ", nrdy=%d)\n", CPU->id, THREAD->tid, THREAD->priority,
    521523            THREAD->ticks, atomic_get(&CPU->nrdy));
    522524#endif

  • uspace/lib/c/arch/sparc32/include/libarch/barrier.h

    rb6b02c0 ref9a2a8  
    1 ../../../../../../../kernel/arch/sparc64/include/arch/barrier.h
     1../../../../../../../kernel/arch/sparc32/include/arch/barrier.h
Note: See TracChangeset for help on using the changeset viewer.