Changes in / [7aaed09:1761268] in mainline


Ignore:
Files:
31 deleted
66 edited

Legend:

Unmodified
Added
Removed

  • kernel/Makefile

    r7aaed09 r1761268  
    229229        generic/src/syscall/syscall.c \
    230230        generic/src/syscall/copy.c \
    231         generic/src/mm/km.c \
    232231        generic/src/mm/reserve.c \
    233232        generic/src/mm/buddy.c \
    … …  
    246245        generic/src/lib/str.c \
    247246        generic/src/lib/elf.c \
    248         generic/src/lib/ra.c \
    249247        generic/src/lib/rd.c \
    250248        generic/src/printf/printf_core.c \

  • kernel/arch/abs32le/Makefile.inc

    r7aaed09 r1761268  
    5757        arch/$(KARCH)/src/smp/smp.c \
    5858        arch/$(KARCH)/src/smp/ipi.c \
    59         arch/$(KARCH)/src/mm/km.c \
    6059        arch/$(KARCH)/src/mm/as.c \
    6160        arch/$(KARCH)/src/mm/frame.c \

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

    r7aaed09 r1761268  
    4141#include <typedefs.h>
    4242
    43 extern void frame_low_arch_init(void);
    44 extern void frame_high_arch_init(void);
     43extern void frame_arch_init(void);
    4544extern void physmem_print(void);
    4645

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

    r7aaed09 r1761268  
    5050
    5151
    52 void frame_low_arch_init(void)
    53 {
    54 }
    55 
    56 void frame_high_arch_init(void)
     52void frame_arch_init(void)
    5753{
    5854}

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

    r7aaed09 r1761268  
    5656}
    5757
     58
     59uintptr_t hw_map(uintptr_t physaddr, size_t size)
     60{
     61        return physaddr;
     62}
     63
    5864void page_fault(unsigned int n __attribute__((unused)), istate_t *istate)
    5965{

  • kernel/arch/amd64/Makefile.inc

    r7aaed09 r1761268  
    8686        arch/$(KARCH)/src/bios/bios.c \
    8787        arch/$(KARCH)/src/interrupt.c \
    88         arch/$(KARCH)/src/mm/km.c \
    8988        arch/$(KARCH)/src/mm/as.c \
    9089        arch/$(KARCH)/src/mm/frame.c \

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

    r7aaed09 r1761268  
    4343#include <typedefs.h>
    4444
    45 extern void frame_low_arch_init(void);
    46 extern void frame_high_arch_init(void);
     45extern uintptr_t last_frame;
     46extern void frame_arch_init(void);
    4747extern void physmem_print(void);
    4848

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

    r7aaed09 r1761268  
    4646#include <panic.h>
    4747#include <align.h>
    48 #include <macros.h>
    4948
    5049void page_arch_init(void)
    5150{
    52         if (config.cpu_active > 1) {
     51        if (config.cpu_active == 1) {
     52                uintptr_t cur;
     53                unsigned int identity_flags =
     54                    PAGE_CACHEABLE | PAGE_EXEC | PAGE_GLOBAL | PAGE_WRITE;
     55               
     56                page_mapping_operations = &pt_mapping_operations;
     57               
     58                page_table_lock(AS_KERNEL, true);
     59               
     60                /*
     61                 * PA2KA(identity) mapping for all frames.
     62                 */
     63                for (cur = 0; cur < last_frame; cur += FRAME_SIZE)
     64                        page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, identity_flags);
     65               
     66                page_table_unlock(AS_KERNEL, true);
     67               
     68                exc_register(14, "page_fault", true, (iroutine_t) page_fault);
    5369                write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
    54                 return;
    55         }
    56 
    57         uintptr_t cur;
    58         unsigned int identity_flags =
    59             PAGE_CACHEABLE | PAGE_EXEC | PAGE_GLOBAL | PAGE_WRITE;
    60                
    61         page_mapping_operations = &pt_mapping_operations;
    62                
    63         page_table_lock(AS_KERNEL, true);
    64                
    65         /*
    66          * PA2KA(identity) mapping for all low-memory frames.
    67          */
    68         for (cur = 0; cur < min(config.identity_size, config.physmem_end);
    69             cur += FRAME_SIZE)
    70                 page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, identity_flags);
    71                
    72         page_table_unlock(AS_KERNEL, true);
    73                
    74         exc_register(14, "page_fault", true, (iroutine_t) page_fault);
    75         write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
     70        } else
     71                write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
    7672}
    7773
    … …  
    9894}
    9995
     96uintptr_t hw_map(uintptr_t physaddr, size_t size)
     97{
     98        if (last_frame + ALIGN_UP(size, PAGE_SIZE) > KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH))
     99                panic("Unable to map physical memory %p (%zu bytes).",
     100                    (void *) physaddr, size);
     101       
     102        uintptr_t virtaddr = PA2KA(last_frame);
     103        pfn_t i;
     104       
     105        page_table_lock(AS_KERNEL, true);
     106       
     107        for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++)
     108                page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i), physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE | PAGE_WRITE);
     109       
     110        page_table_unlock(AS_KERNEL, true);
     111       
     112        last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);
     113       
     114        return virtaddr;
     115}
     116
    100117/** @}
    101118 */

  • kernel/arch/arm32/Makefile.inc

    r7aaed09 r1761268  
    5353        arch/$(KARCH)/src/debug/stacktrace.c \
    5454        arch/$(KARCH)/src/debug/stacktrace_asm.S \
    55         arch/$(KARCH)/src/mm/km.c \
    5655        arch/$(KARCH)/src/mm/as.c \
    5756        arch/$(KARCH)/src/mm/frame.c \

  • kernel/arch/arm32/include/mach/integratorcp/integratorcp.h

    r7aaed09 r1761268  
    103103extern void icp_cpu_halt(void);
    104104extern void icp_irq_exception(unsigned int, istate_t *);
    105 extern void icp_get_memory_extents(uintptr_t *, size_t *);
     105extern void icp_get_memory_extents(uintptr_t *, uintptr_t *);
    106106extern void icp_frame_init(void);
    107107extern size_t icp_get_irq_count(void);

  • kernel/arch/arm32/include/mach/testarm/testarm.h

    r7aaed09 r1761268  
    7171extern void gxemul_cpu_halt(void);
    7272extern void gxemul_irq_exception(unsigned int, istate_t *);
    73 extern void gxemul_get_memory_extents(uintptr_t *, size_t *);
     73extern void gxemul_get_memory_extents(uintptr_t *, uintptr_t *);
    7474extern void gxemul_frame_init(void);
    7575extern size_t gxemul_get_irq_count(void);

  • kernel/arch/arm32/include/machine_func.h

    r7aaed09 r1761268  
    5050        void (*machine_timer_irq_start)(void);
    5151        void (*machine_cpu_halt)(void);
    52         void (*machine_get_memory_extents)(uintptr_t *, size_t *);
     52        void (*machine_get_memory_extents)(uintptr_t *, uintptr_t *);
    5353        void (*machine_irq_exception)(unsigned int, istate_t *);
    5454        void (*machine_frame_init)(void);
    … …  
    8181 * @param size          Place to store memory size.
    8282 */
    83 extern void machine_get_memory_extents(uintptr_t *start, size_t *size);
     83extern void machine_get_memory_extents(uintptr_t *start, uintptr_t *size);
    8484
    8585/** Interrupt exception handler.

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

    r7aaed09 r1761268  
    6161#endif
    6262
    63 extern void frame_low_arch_init(void);
    64 extern void frame_high_arch_init(void);
     63extern uintptr_t last_frame;
     64
     65extern void frame_arch_init(void);
    6566extern void boot_page_table_free(void);
    6667#define physmem_print()

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

    r7aaed09 r1761268  
    5454
    5555/* Number of entries in each level. */
    56 #define PTL0_ENTRIES_ARCH       (1 << 12)       /* 4096 */
     56#define PTL0_ENTRIES_ARCH       (2 << 12)       /* 4096 */
    5757#define PTL1_ENTRIES_ARCH       0
    5858#define PTL2_ENTRIES_ARCH       0
    5959/* coarse page tables used (256 * 4 = 1KB per page) */
    60 #define PTL3_ENTRIES_ARCH       (1 << 8)        /* 256 */
     60#define PTL3_ENTRIES_ARCH       (2 << 8)        /* 256 */
    6161
    6262/* Page table sizes for each level. */

  • kernel/arch/arm32/src/mach/gta02/gta02.c

    r7aaed09 r1761268  
    6565static void gta02_timer_irq_start(void);
    6666static void gta02_cpu_halt(void);
    67 static void gta02_get_memory_extents(uintptr_t *start, size_t *size);
     67static void gta02_get_memory_extents(uintptr_t *start, uintptr_t *size);
    6868static void gta02_irq_exception(unsigned int exc_no, istate_t *istate);
    6969static void gta02_frame_init(void);
    … …  
    123123 * @param size          Place to store memory size.
    124124 */
    125 static void gta02_get_memory_extents(uintptr_t *start, size_t *size)
     125static void gta02_get_memory_extents(uintptr_t *start, uintptr_t *size)
    126126{
    127127        *start = GTA02_MEMORY_START + GTA02_MEMORY_SKIP;

  • kernel/arch/arm32/src/mach/integratorcp/integratorcp.c

    r7aaed09 r1761268  
    220220 * @param size          Place to store memory size.
    221221 */
    222 void icp_get_memory_extents(uintptr_t *start, size_t *size)
     222void icp_get_memory_extents(uintptr_t *start, uintptr_t *size)
    223223{
    224224        *start = 0;

  • kernel/arch/arm32/src/mach/testarm/testarm.c

    r7aaed09 r1761268  
    202202 * @param size          Place to store memory size.
    203203 */
    204 void gxemul_get_memory_extents(uintptr_t *start, size_t *size)
     204void gxemul_get_memory_extents(uintptr_t *start, uintptr_t *size)
    205205{
    206206        *start = 0;
    207         *size = *((uintptr_t *) (GXEMUL_MP_ADDRESS + GXEMUL_MP_MEMSIZE_OFFSET));
     207        *size = *((uintptr_t *) (GXEMUL_MP_ADDRESS + GXEMUL_MP_MEMSIZE_OFFSET));
    208208}
    209209

  • kernel/arch/arm32/src/machine_func.c

    r7aaed09 r1761268  
    8585 * @param size          Place to store memory size.
    8686 */
    87 void machine_get_memory_extents(uintptr_t *start, size_t *size)
     87void machine_get_memory_extents(uintptr_t *start, uintptr_t *size)
    8888{
    8989        (machine_ops->machine_get_memory_extents)(start, size);

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

    r7aaed09 r1761268  
    3939#include <config.h>
    4040#include <align.h>
    41 #include <macros.h>
    4241
    43 static void frame_common_arch_init(bool low)
     42/** Address of the last frame in the memory. */
     43uintptr_t last_frame = 0;
     44
     45/** Creates memory zones. */
     46void frame_arch_init(void)
    4447{
    45         uintptr_t base;
    46         size_t size;
     48        uintptr_t mem_start, mem_size;
     49        uintptr_t first_frame;
     50        uintptr_t num_frames;
    4751
    48         machine_get_memory_extents(&base, &size);
    49         base = ALIGN_UP(base, FRAME_SIZE);
    50         size = ALIGN_DOWN(size, FRAME_SIZE);
     52        machine_get_memory_extents(&mem_start, &mem_size);
     53        first_frame = ALIGN_UP(mem_start, FRAME_SIZE);
     54        last_frame = ALIGN_DOWN(mem_start + mem_size, FRAME_SIZE);
     55        num_frames = (last_frame - first_frame) >> FRAME_WIDTH;
    5156       
    52         if (!frame_adjust_zone_bounds(low, &base, &size))
    53                 return;
    54 
    55         if (low) {
    56                 zone_create(ADDR2PFN(base), SIZE2FRAMES(size),
    57                     BOOT_PAGE_TABLE_START_FRAME +
    58                     BOOT_PAGE_TABLE_SIZE_IN_FRAMES,
    59                     ZONE_AVAILABLE | ZONE_LOWMEM);
    60         } else {
    61                 pfn_t conf = zone_external_conf_alloc(SIZE2FRAMES(size));
    62 
    63                 zone_create(ADDR2PFN(base), SIZE2FRAMES(size), conf,
    64                     ZONE_AVAILABLE | ZONE_HIGHMEM);
    65         }
     57        /* All memory as one zone */
     58        zone_create(first_frame >> FRAME_WIDTH, num_frames,
     59            BOOT_PAGE_TABLE_START_FRAME + BOOT_PAGE_TABLE_SIZE_IN_FRAMES, 0);
    6660       
    67 }
    68 
    69 /** Create low memory zones. */
    70 void frame_low_arch_init(void)
    71 {
    72         frame_common_arch_init(true);
    73 
    7461        /* blacklist boot page table */
    7562        frame_mark_unavailable(BOOT_PAGE_TABLE_START_FRAME,
    … …  
    7764
    7865        machine_frame_init();
    79 }
    80 
    81 /** Create high memory zones. */
    82 void frame_high_arch_init(void)
    83 {
    84         frame_common_arch_init(false);
    8566}
    8667

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

    r7aaed09 r1761268  
    3737#include <genarch/mm/page_pt.h>
    3838#include <mm/page.h>
    39 #include <arch/mm/frame.h>
    4039#include <align.h>
    4140#include <config.h>
    … …  
    4342#include <typedefs.h>
    4443#include <interrupt.h>
    45 #include <macros.h>
     44#include <arch/mm/frame.h>
    4645
    4746/** Initializes page tables.
    … …  
    5857       
    5958        uintptr_t cur;
    60 
    6159        /* Kernel identity mapping */
    62         for (cur = PHYSMEM_START_ADDR;
    63             cur < min(config.identity_size, config.physmem_end);
    64             cur += FRAME_SIZE)
     60        for (cur = PHYSMEM_START_ADDR; cur < last_frame; cur += FRAME_SIZE)
    6561                page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
    6662       
    6763        /* Create mapping for exception table at high offset */
    6864#ifdef HIGH_EXCEPTION_VECTORS
    69         // XXX: fixme to use proper non-identity page
    7065        void *virtaddr = frame_alloc(ONE_FRAME, FRAME_KA);
    71         page_mapping_insert(AS_KERNEL, EXC_BASE_ADDRESS, KA2PA(virtaddr),
    72             flags);
     66        page_mapping_insert(AS_KERNEL, EXC_BASE_ADDRESS, KA2PA(virtaddr), flags);
    7367#else
    7468#error "Only high exception vector supported now"
    … …  
    8478}
    8579
     80/** Maps device into the kernel space.
     81 *
     82 * Maps physical address of device into kernel virtual address space (so it can
     83 * be accessed only by kernel through virtual address).
     84 *
     85 * @param physaddr Physical address where device is connected.
     86 * @param size Length of area where device is present.
     87 *
     88 * @return Virtual address where device will be accessible.
     89 */
     90uintptr_t hw_map(uintptr_t physaddr, size_t size)
     91{
     92        if (last_frame + ALIGN_UP(size, PAGE_SIZE) >
     93            KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH)) {
     94                panic("Unable to map physical memory %p (%d bytes).",
     95                    (void *) physaddr, size);
     96        }
     97       
     98        uintptr_t virtaddr = PA2KA(last_frame);
     99        pfn_t i;
     100
     101        page_table_lock(AS_KERNEL, true);
     102        for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++) {
     103                page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i),
     104                    physaddr + PFN2ADDR(i),
     105                    PAGE_NOT_CACHEABLE | PAGE_READ | PAGE_WRITE | PAGE_KERNEL);
     106        }
     107        page_table_unlock(AS_KERNEL, true);
     108       
     109        last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);
     110        return virtaddr;
     111}
     112
    86113/** @}
    87114 */

  • kernel/arch/ia32/Makefile.inc

    r7aaed09 r1761268  
    9999        arch/$(KARCH)/src/userspace.c \
    100100        arch/$(KARCH)/src/cpu/cpu.c \
    101         arch/$(KARCH)/src/mm/km.c \
    102101        arch/$(KARCH)/src/mm/as.c \
    103102        arch/$(KARCH)/src/mm/frame.c \

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

    r7aaed09 r1761268  
    4343#include <typedefs.h>
    4444
    45 extern void frame_low_arch_init(void);
    46 extern void frame_high_arch_init(void);
     45extern uintptr_t last_frame;
     46
     47extern void frame_arch_init(void);
    4748extern void physmem_print(void);
    4849

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

    r7aaed09 r1761268  
    4646#include <print.h>
    4747
     48#define PHYSMEM_LIMIT32  UINT64_C(0x07c000000)
     49#define PHYSMEM_LIMIT64  UINT64_C(0x200000000)
     50
    4851size_t hardcoded_unmapped_ktext_size = 0;
    4952size_t hardcoded_unmapped_kdata_size = 0;
    5053
    51 static void init_e820_memory(pfn_t minconf, bool low)
     54uintptr_t last_frame = 0;
     55
     56static void init_e820_memory(pfn_t minconf)
    5257{
    5358        unsigned int i;
    5459       
    5560        for (i = 0; i < e820counter; i++) {
    56                 uintptr_t base = (uintptr_t) e820table[i].base_address;
    57                 size_t size = (size_t) e820table[i].size;
    58                
    59                 if (!frame_adjust_zone_bounds(low, &base, &size))
     61                uint64_t base = e820table[i].base_address;
     62                uint64_t size = e820table[i].size;
     63               
     64#ifdef __32_BITS__
     65                /*
     66                 * XXX FIXME:
     67                 *
     68                 * Ignore zones which start above PHYSMEM_LIMIT32
     69                 * or clip zones which go beyond PHYSMEM_LIMIT32.
     70                 *
     71                 * The PHYSMEM_LIMIT32 (2 GB - 64 MB) is a rather
     72                 * arbitrary constant which allows to have at
     73                 * least 64 MB in the kernel address space to
     74                 * map hardware resources.
     75                 *
     76                 * The kernel uses fixed 1:1 identity mapping
     77                 * of the physical memory with 2:2 GB split.
     78                 * This is a severe limitation of the current
     79                 * kernel memory management.
     80                 *
     81                 */
     82               
     83                if (base > PHYSMEM_LIMIT32)
    6084                        continue;
     85               
     86                if (base + size > PHYSMEM_LIMIT32)
     87                        size = PHYSMEM_LIMIT32 - base;
     88#endif
     89               
     90#ifdef __64_BITS__
     91                /*
     92                 * XXX FIXME:
     93                 *
     94                 * Ignore zones which start above PHYSMEM_LIMIT64
     95                 * or clip zones which go beyond PHYSMEM_LIMIT64.
     96                 *
     97                 * The PHYSMEM_LIMIT64 (8 GB) is the size of the
     98                 * fixed 1:1 identically mapped physical memory
     99                 * accessible during the bootstrap process.
     100                 * This is a severe limitation of the current
     101                 * kernel memory management.
     102                 *
     103                 */
     104               
     105                if (base > PHYSMEM_LIMIT64)
     106                        continue;
     107               
     108                if (base + size > PHYSMEM_LIMIT64)
     109                        size = PHYSMEM_LIMIT64 - base;
     110#endif
    61111               
    62112                if (e820table[i].type == MEMMAP_MEMORY_AVAILABLE) {
    … …  
    66116                            FRAME_SIZE);
    67117                       
     118                        pfn_t pfn = ADDR2PFN(new_base);
    68119                        size_t count = SIZE2FRAMES(new_size);
    69                         pfn_t pfn = ADDR2PFN(new_base);
     120                       
    70121                        pfn_t conf;
    71                        
    72                         if (low) {
    73                                 if ((minconf < pfn) || (minconf >= pfn + count))
    74                                         conf = pfn;
    75                                 else
    76                                         conf = minconf;
    77                                 zone_create(pfn, count, conf,
    78                                     ZONE_AVAILABLE | ZONE_LOWMEM);
    79                         } else {
    80                                 conf = zone_external_conf_alloc(count);
    81                                 zone_create(pfn, count, conf,
    82                                     ZONE_AVAILABLE | ZONE_HIGHMEM);
    83                         }
     122                        if ((minconf < pfn) || (minconf >= pfn + count))
     123                                conf = pfn;
     124                        else
     125                                conf = minconf;
     126                       
     127                        zone_create(pfn, count, conf, ZONE_AVAILABLE);
     128                       
     129                        // XXX this has to be removed
     130                        if (last_frame < ALIGN_UP(new_base + new_size, FRAME_SIZE))
     131                                last_frame = ALIGN_UP(new_base + new_size, FRAME_SIZE);
    84132                } else if ((e820table[i].type == MEMMAP_MEMORY_ACPI) ||
    85133                    (e820table[i].type == MEMMAP_MEMORY_NVS)) {
    … …  
    131179
    132180
    133 void frame_low_arch_init(void)
     181void frame_arch_init(void)
    134182{
    135183        pfn_t minconf;
    … …  
    144192#endif
    145193               
    146                 init_e820_memory(minconf, true);
     194                init_e820_memory(minconf);
    147195               
    148196                /* Reserve frame 0 (BIOS data) */
    … …  
    158206}
    159207
    160 void frame_high_arch_init(void)
    161 {
    162         if (config.cpu_active == 1)
    163                 init_e820_memory(0, false);
    164 }
    165 
    166208/** @}
    167209 */

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

    r7aaed09 r1761268  
    4949#include <print.h>
    5050#include <interrupt.h>
    51 #include <macros.h>
    5251
    5352void page_arch_init(void)
    … …  
    5655        int flags;
    5756       
    58         if (config.cpu_active > 1) {
    59                 /* Fast path for non-boot CPUs */
     57        if (config.cpu_active == 1) {
     58                page_mapping_operations = &pt_mapping_operations;
     59       
     60                /*
     61                 * PA2KA(identity) mapping for all frames until last_frame.
     62                 */
     63                page_table_lock(AS_KERNEL, true);
     64                for (cur = 0; cur < last_frame; cur += FRAME_SIZE) {
     65                        flags = PAGE_CACHEABLE | PAGE_WRITE;
     66                        if ((PA2KA(cur) >= config.base) && (PA2KA(cur) < config.base + config.kernel_size))
     67                                flags |= PAGE_GLOBAL;
     68                        page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
     69                }
     70                page_table_unlock(AS_KERNEL, true);
     71               
     72                exc_register(14, "page_fault", true, (iroutine_t) page_fault);
    6073                write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
    61                 paging_on();
    62                 return;
    63         }
     74        } else
     75                write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
     76       
     77        paging_on();
     78}
    6479
    65         page_mapping_operations = &pt_mapping_operations;
     80
     81uintptr_t hw_map(uintptr_t physaddr, size_t size)
     82{
     83        if (last_frame + ALIGN_UP(size, PAGE_SIZE) > KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH))
     84                panic("Unable to map physical memory %p (%zu bytes).",
     85                    (void *) physaddr, size);
    6686       
    67         /*
    68          * PA2KA(identity) mapping for all low-memory frames.
    69          */
     87        uintptr_t virtaddr = PA2KA(last_frame);
     88        pfn_t i;
    7089        page_table_lock(AS_KERNEL, true);
    71         for (cur = 0; cur < min(config.identity_size, config.physmem_end);
    72             cur += FRAME_SIZE) {
    73                 flags = PAGE_CACHEABLE | PAGE_WRITE;
    74                 if ((PA2KA(cur) >= config.base) &&
    75                     (PA2KA(cur) < config.base + config.kernel_size))
    76                         flags |= PAGE_GLOBAL;
    77                 page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
     90        for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++) {
     91                uintptr_t addr = PFN2ADDR(i);
     92                page_mapping_insert(AS_KERNEL, virtaddr + addr, physaddr + addr, PAGE_NOT_CACHEABLE | PAGE_WRITE);
    7893        }
    7994        page_table_unlock(AS_KERNEL, true);
    80                
    81         exc_register(14, "page_fault", true, (iroutine_t) page_fault);
    82         write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
    8395       
    84         paging_on();
     96        last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);
     97       
     98        return virtaddr;
    8599}
    86100

  • kernel/arch/ia64/Makefile.inc

    r7aaed09 r1761268  
    5252        arch/$(KARCH)/src/ivt.S \
    5353        arch/$(KARCH)/src/interrupt.c \
    54         arch/$(KARCH)/src/mm/km.c \
    5554        arch/$(KARCH)/src/mm/as.c \
    5655        arch/$(KARCH)/src/mm/frame.c \

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

    r7aaed09 r1761268  
    4343#include <typedefs.h>
    4444
    45 extern void frame_low_arch_init(void);
    46 extern void frame_high_arch_init(void);
     45extern uintptr_t last_frame;
     46
     47extern void frame_arch_init(void);
    4748#define physmem_print()
    4849

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

    r7aaed09 r1761268  
    5757
    5858/* Firmware area (bellow 4GB in phys mem) */
    59 #define FW_OFFSET   0x00000000F0000000  // FIXME: [non-ident]
     59#define FW_OFFSET   0x00000000F0000000
    6060/* Legacy IO space */
    61 #define IO_OFFSET   0x0001000000000000  // FIXME: [non-ident]
     61#define IO_OFFSET   0x0001000000000000
    6262/* Videoram - now mapped to 0 as VGA text mode vram on 0xb8000 */
    63 #define VIO_OFFSET  0x0002000000000000  // FIXME: [non-ident]
     63#define VIO_OFFSET  0x0002000000000000
    6464
    6565

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

    r7aaed09 r1761268  
    5151#define MINCONF 1
    5252
    53 static void frame_common_arch_init(bool low)
     53uintptr_t last_frame = 0;
     54
     55void frame_arch_init(void)
    5456{
    55         unsigned int i;
     57        if (config.cpu_active == 1) {
     58                unsigned int i;
     59                for (i = 0; i < bootinfo->memmap_items; i++) {
     60                        if (bootinfo->memmap[i].type == MEMMAP_FREE_MEM) {
     61                                uint64_t base = bootinfo->memmap[i].base;
     62                                uint64_t size = bootinfo->memmap[i].size;
     63                                uint64_t abase = ALIGN_UP(base, FRAME_SIZE);
    5664
    57         for (i = 0; i < bootinfo->memmap_items; i++) {
    58                 if (bootinfo->memmap[i].type != MEMMAP_FREE_MEM)
    59                         continue;
     65                                if (size > FRAME_SIZE)
     66                                        size -= abase - base;
    6067
    61                 uintptr_t base = bootinfo->memmap[i].base;
    62                 size_t size = bootinfo->memmap[i].size;
    63                 uintptr_t abase = ALIGN_UP(base, FRAME_SIZE);
    64 
    65                 if (size > FRAME_SIZE)
    66                         size -= abase - base;
    67 
    68                 if (!frame_adjust_zone_bounds(low, &abase, &size))
    69                         continue;
    70 
    71                 if (size > MIN_ZONE_SIZE) {
    72                         pfn_t pfn = ADDR2PFN(abase);
    73                         size_t count = SIZE2FRAMES(size);
    74 
    75                         if (low) {
    76                                 zone_create(pfn, count, max(MINCONF, pfn),
    77                                     ZONE_AVAILABLE | ZONE_LOWMEM);
    78                         } else {
    79                                 pfn_t conf;
    80 
    81                                 conf = zone_external_conf_alloc(count);
    82                                 zone_create(pfn, count, conf,
    83                                     ZONE_AVAILABLE | ZONE_HIGHMEM);
     68                                if (size > MIN_ZONE_SIZE) {
     69                                        zone_create(abase >> FRAME_WIDTH,
     70                                            size >> FRAME_WIDTH,
     71                                            max(MINCONF, abase >> FRAME_WIDTH),
     72                                            0);
     73                                }
     74                                if (abase + size > last_frame)
     75                                        last_frame = abase + size;
    8476                        }
    8577                }
    86         }
    87 }
     78               
     79                /*
     80                 * Blacklist ROM regions.
     81                 */
     82                frame_mark_unavailable(ADDR2PFN(ROM_BASE),
     83                    SIZE2FRAMES(ROM_SIZE));
    8884
    89 void frame_low_arch_init(void)
    90 {
    91         if (config.cpu_active > 1)
    92                 return;
    93        
    94         frame_common_arch_init(true);
    95        
    96         /*
    97          * Blacklist ROM regions.
    98          */
    99         frame_mark_unavailable(ADDR2PFN(ROM_BASE),
    100             SIZE2FRAMES(ROM_SIZE));
    101 
    102         frame_mark_unavailable(ADDR2PFN(KERNEL_RESERVED_AREA_BASE),
    103             SIZE2FRAMES(KERNEL_RESERVED_AREA_SIZE));
    104 }
    105 
    106 void frame_high_arch_init(void)
    107 {
    108         if (config.cpu_active > 1)
    109                 return;
    110        
    111         frame_common_arch_init(false);
     85                frame_mark_unavailable(ADDR2PFN(KERNEL_RESERVED_AREA_BASE),
     86                    SIZE2FRAMES(KERNEL_RESERVED_AREA_SIZE));
     87        }       
    11288}
    11389

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

    r7aaed09 r1761268  
    255255}
    256256
     257uintptr_t hw_map(uintptr_t physaddr, size_t size __attribute__ ((unused)))
     258{
     259        /* THIS is a dirty hack. */
     260        return (uintptr_t)((uint64_t)(PA2KA(physaddr)) + VIO_OFFSET);
     261}
     262
    257263/** @}
    258264 */

  • kernel/arch/ia64/src/mm/tlb.c

    r7aaed09 r1761268  
    480480        va = istate->cr_ifa; /* faulting address */
    481481       
     482        page_table_lock(AS, true);
    482483        t = page_mapping_find(AS, va, true);
    483484        if (t) {
    … …  
    487488                 */
    488489                itc_pte_copy(t);
     490                page_table_unlock(AS, true);
    489491        } else {
    490492                /*
    491493                 * Forward the page fault to address space page fault handler.
    492494                 */
     495                page_table_unlock(AS, true);
    493496                if (as_page_fault(va, PF_ACCESS_EXEC, istate) == AS_PF_FAULT) {
    494497                        fault_if_from_uspace(istate, "Page fault at %p.",
    … …  
    595598       
    596599       
     600        page_table_lock(AS, true);
    597601        pte_t *entry = page_mapping_find(AS, va, true);
    598602        if (entry) {
    … …  
    602606                 */
    603607                dtc_pte_copy(entry);
     608                page_table_unlock(AS, true);
    604609        } else {
     610                page_table_unlock(AS, true);
    605611                if (try_memmap_io_insertion(va, istate))
    606612                        return;
    … …  
    644650        va = istate->cr_ifa;  /* faulting address */
    645651       
     652        page_table_lock(AS, true);
    646653        t = page_mapping_find(AS, va, true);
    647654        ASSERT((t) && (t->p));
    … …  
    660667                }
    661668        }
     669        page_table_unlock(AS, true);
    662670}
    663671
    … …  
    675683        va = istate->cr_ifa;  /* faulting address */
    676684       
     685        page_table_lock(AS, true);
    677686        t = page_mapping_find(AS, va, true);
    678687        ASSERT((t) && (t->p));
    … …  
    691700                }
    692701        }
     702        page_table_unlock(AS, true);
    693703}
    694704
    … …  
    706716        va = istate->cr_ifa;  /* faulting address */
    707717       
     718        page_table_lock(AS, true);
    708719        t = page_mapping_find(AS, va, true);
    709720        ASSERT((t) && (t->p));
    … …  
    722733                }
    723734        }
     735        page_table_unlock(AS, true);
    724736}
    725737
    … …  
    740752         * Assume a write to a read-only page.
    741753         */
     754        page_table_lock(AS, true);
    742755        t = page_mapping_find(AS, va, true);
    743756        ASSERT((t) && (t->p));
    … …  
    748761                panic_memtrap(istate, PF_ACCESS_WRITE, va, NULL);
    749762        }
     763        page_table_unlock(AS, true);
    750764}
    751765
    … …  
    763777        va = istate->cr_ifa;  /* faulting address */
    764778       
     779        page_table_lock(AS, true);
    765780        t = page_mapping_find(AS, va, true);
    766781        ASSERT(t);
    … …  
    775790                else
    776791                        dtc_pte_copy(t);
     792                page_table_unlock(AS, true);
    777793        } else {
     794                page_table_unlock(AS, true);
    778795                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    779796                        fault_if_from_uspace(istate, "Page fault at %p.",

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

    r7aaed09 r1761268  
    3838#define KERNEL_TRANSLATION_I    0x0010000000000661
    3939#define KERNEL_TRANSLATION_D    0x0010000000000661
    40 #define KERNEL_TRANSLATION_VIO  0x0010000000000671      // FIXME: [non-ident]
    41 #define KERNEL_TRANSLATION_IO   0x00100FFFFC000671      // FIXME: [non-ident]
    42 #define KERNEL_TRANSLATION_FW   0x00100000F0000671      // FIXME: [non-ident]
     40#define KERNEL_TRANSLATION_VIO  0x0010000000000671
     41#define KERNEL_TRANSLATION_IO   0x00100FFFFC000671
     42#define KERNEL_TRANSLATION_FW   0x00100000F0000671
    4343
    4444.section K_TEXT_START, "ax"

  • kernel/arch/mips32/Makefile.inc

    r7aaed09 r1761268  
    6363        arch/$(KARCH)/src/debug/stacktrace.c \
    6464        arch/$(KARCH)/src/debug/stacktrace_asm.S \
    65         arch/$(KARCH)/src/mm/km.c \
    6665        arch/$(KARCH)/src/mm/frame.c \
    6766        arch/$(KARCH)/src/mm/page.c \

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

    r7aaed09 r1761268  
    4141#ifndef __ASM__
    4242
    43 extern void frame_low_arch_init(void);
    44 extern void frame_high_arch_init(void);
     43extern void frame_arch_init(void);
    4544extern void physmem_print(void);
    4645

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

    r7aaed09 r1761268  
    131131}
    132132
    133 static void frame_add_region(pfn_t start_frame, pfn_t end_frame, bool low)
    134 {
    135         if (end_frame <= start_frame)
    136                 return;
    137 
    138         uintptr_t base = start_frame << ZERO_PAGE_WIDTH;
    139         size_t size = (end_frame - start_frame) << ZERO_PAGE_WIDTH;
    140 
    141         if (!frame_adjust_zone_bounds(low, &base, &size))
    142                 return;
    143 
    144         pfn_t first = ADDR2PFN(base);
    145         size_t count = SIZE2FRAMES(size);
    146         pfn_t conf_frame;
    147 
    148         if (low) {
     133static void frame_add_region(pfn_t start_frame, pfn_t end_frame)
     134{
     135        if (end_frame > start_frame) {
     136                /* Convert 1M frames to 16K frames */
     137                pfn_t first = ADDR2PFN(start_frame << ZERO_PAGE_WIDTH);
     138                pfn_t count = ADDR2PFN((end_frame - start_frame) << ZERO_PAGE_WIDTH);
     139               
    149140                /* Interrupt vector frame is blacklisted */
     141                pfn_t conf_frame;
    150142                if (first == 0)
    151143                        conf_frame = 1;
    152144                else
    153145                        conf_frame = first;
    154                 zone_create(first, count, conf_frame,
    155                     ZONE_AVAILABLE | ZONE_LOWMEM);
    156         } else {
    157                 conf_frame = zone_external_conf_alloc(count);
    158                 zone_create(first, count, conf_frame,
    159                     ZONE_AVAILABLE | ZONE_HIGHMEM);
    160         }
    161                
    162                
    163         if (phys_regions_count < MAX_REGIONS) {
    164                 phys_regions[phys_regions_count].start = first;
    165                 phys_regions[phys_regions_count].count = count;
    166                 phys_regions_count++;
     146               
     147                zone_create(first, count, conf_frame, 0);
     148               
     149                if (phys_regions_count < MAX_REGIONS) {
     150                        phys_regions[phys_regions_count].start = first;
     151                        phys_regions[phys_regions_count].count = count;
     152                        phys_regions_count++;
     153                }
    167154        }
    168155}
    … …  
    178165 *
    179166 */
    180 void frame_low_arch_init(void)
     167void frame_arch_init(void)
    181168{
    182169        ipl_t ipl = interrupts_disable();
    … …  
    237224               
    238225                if (!avail) {
    239                         frame_add_region(start_frame, frame, true);
     226                        frame_add_region(start_frame, frame);
    240227                        start_frame = frame + 1;
    241228                        avail = true;
    … …  
    243230        }
    244231       
    245         frame_add_region(start_frame, frame, true);
     232        frame_add_region(start_frame, frame);
    246233       
    247234        /* Blacklist interrupt vector frame */
    … …  
    259246}
    260247
    261 void frame_high_arch_init(void)
    262 {
    263 }
    264248
    265249void physmem_print(void)

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

    r7aaed09 r1761268  
    4141{
    4242        page_mapping_operations = &pt_mapping_operations;
    43         as_switch(NULL, AS_KERNEL);
     43}
     44
     45/** Map device into kernel space
     46 * - on mips, all devices are already mapped into kernel space,
     47 *   translate the physical address to uncached area
     48 */
     49uintptr_t hw_map(uintptr_t physaddr, size_t size)
     50{
     51        return physaddr + 0xa0000000;
    4452}
    4553

  • kernel/arch/mips64/Makefile.inc

    r7aaed09 r1761268  
    5555        arch/$(KARCH)/src/debug/stacktrace.c \
    5656        arch/$(KARCH)/src/debug/stacktrace_asm.S \
    57         arch/$(KARCH)/src/mm/km.c \
    5857        arch/$(KARCH)/src/mm/frame.c \
    5958        arch/$(KARCH)/src/mm/page.c \

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

    r7aaed09 r1761268  
    4141#ifndef __ASM__
    4242
    43 extern void frame_low_arch_init(void);
    44 extern void frame_high_arch_init(void);
     43extern void frame_arch_init(void);
    4544extern void physmem_print(void);
    4645

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

    r7aaed09 r1761268  
    123123}
    124124
    125 static void frame_add_region(pfn_t start_frame, pfn_t end_frame, bool low)
    126 {
    127         if (end_frame <= start_frame)
    128                 return;
    129 
    130         uintptr_t base = start_frame << ZERO_PAGE_WIDTH;
    131         size_t size = (end_frame - start_frame) << ZERO_PAGE_WIDTH;
    132 
    133         if (!frame_adjust_zone_bounds(low, &base, &size))
    134                 return;
    135 
    136         pfn_t first = ADDR2PFN(base);
    137         size_t count = SIZE2FRAMES(size);
    138         pfn_t conf_frame;
    139 
    140         if (low) {
     125static void frame_add_region(pfn_t start_frame, pfn_t end_frame)
     126{
     127        if (end_frame > start_frame) {
     128                /* Convert 1M frames to 16K frames */
     129                pfn_t first = ADDR2PFN(start_frame << ZERO_PAGE_WIDTH);
     130                pfn_t count = ADDR2PFN((end_frame - start_frame) << ZERO_PAGE_WIDTH);
     131               
    141132                /* Interrupt vector frame is blacklisted */
     133                pfn_t conf_frame;
    142134                if (first == 0)
    143135                        conf_frame = 1;
    144136                else
    145137                        conf_frame = first;
    146                 zone_create(first, count, conf_frame,
    147                     ZONE_AVAILABLE | ZONE_LOWMEM);
    148         } else {
    149                 conf_frame = zone_external_conf_alloc(count);
    150                 zone_create(first, count, conf_frame,
    151                     ZONE_AVAILABLE | ZONE_HIGHMEM);
    152         }
    153                
    154                
    155         if (phys_regions_count < MAX_REGIONS) {
    156                 phys_regions[phys_regions_count].start = first;
    157                 phys_regions[phys_regions_count].count = count;
    158                 phys_regions_count++;
     138               
     139                zone_create(first, count, conf_frame, 0);
     140               
     141                if (phys_regions_count < MAX_REGIONS) {
     142                        phys_regions[phys_regions_count].start = first;
     143                        phys_regions[phys_regions_count].count = count;
     144                        phys_regions_count++;
     145                }
    159146        }
    160147}
    … …  
    169156 *
    170157 */
    171 void frame_low_arch_init(void)
     158void frame_arch_init(void)
    172159{
    173160        ipl_t ipl = interrupts_disable();
    … …  
    220207               
    221208                if (!avail) {
    222                         frame_add_region(start_frame, frame, true);
     209                        frame_add_region(start_frame, frame);
    223210                        start_frame = frame + 1;
    224211                        avail = true;
    … …  
    226213        }
    227214       
    228         frame_add_region(start_frame, frame, true);
     215        frame_add_region(start_frame, frame);
    229216       
    230217        /* Blacklist interrupt vector frame */
    … …  
    242229}
    243230
    244 void frame_high_arch_init(void)
    245 {
    246 }
    247 
    248231void physmem_print(void)
    249232{

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

    r7aaed09 r1761268  
    4343}
    4444
     45/** Map device into kernel space
     46 * - on mips, all devices are already mapped into kernel space,
     47 *   translate the physical address to uncached area
     48 */
     49uintptr_t hw_map(uintptr_t physaddr, size_t size)
     50{
     51        return physaddr + 0xffffffffa0000000;
     52}
     53
    4554/** @}
    4655 */

  • kernel/arch/ppc32/Makefile.inc

    r7aaed09 r1761268  
    5252        arch/$(KARCH)/src/proc/scheduler.c \
    5353        arch/$(KARCH)/src/ddi/ddi.c \
    54         arch/$(KARCH)/src/mm/km.c \
    5554        arch/$(KARCH)/src/mm/as.c \
    5655        arch/$(KARCH)/src/mm/frame.c \

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

    r7aaed09 r1761268  
    4444#include <trace.h>
    4545
     46extern uintptr_t last_frame;
     47
    4648NO_TRACE static inline uint32_t physmem_top(void)
    4749{
    … …  
    5658}
    5759
    58 extern void frame_low_arch_init(void);
    59 extern void frame_high_arch_init(void);
     60extern void frame_arch_init(void);
    6061extern void physmem_print(void);
    6162

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

    r7aaed09 r1761268  
    4040#include <print.h>
    4141
     42uintptr_t last_frame = 0;
    4243memmap_t memmap;
    4344
    … …  
    5354}
    5455
    55 static void frame_common_arch_init(bool low)
     56void frame_arch_init(void)
    5657{
    5758        pfn_t minconf = 2;
    … …  
    6061        for (i = 0; i < memmap.cnt; i++) {
    6162                /* To be safe, make the available zone possibly smaller */
    62                 uintptr_t base = ALIGN_UP((uintptr_t) memmap.zones[i].start,
     63                uintptr_t new_start = ALIGN_UP((uintptr_t) memmap.zones[i].start,
    6364                    FRAME_SIZE);
    64                 size_t size = ALIGN_DOWN(memmap.zones[i].size -
    65                     (base - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
     65                size_t new_size = ALIGN_DOWN(memmap.zones[i].size -
     66                    (new_start - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
    6667               
    67                 if (!frame_adjust_zone_bounds(low, &base, &size))
    68                         return;
    69 
    70                 pfn_t pfn = ADDR2PFN(base);
    71                 size_t count = SIZE2FRAMES(size);
     68                pfn_t pfn = ADDR2PFN(new_start);
     69                size_t count = SIZE2FRAMES(new_size);
     70               
    7271                pfn_t conf;
    73 
    74                 if (low) {
    75                         if ((minconf < pfn) || (minconf >= pfn + count))
    76                                 conf = pfn;
    77                         else
    78                                 conf = minconf;
    79                         zone_create(pfn, count, conf,
    80                             ZONE_AVAILABLE | ZONE_LOWMEM);
    81                 } else {
    82                         conf = zone_external_conf_alloc(count);
    83                         zone_create(pfn, count, conf,
    84                             ZONE_AVAILABLE | ZONE_HIGHMEM);
    85                 }
     72                if ((minconf < pfn) || (minconf >= pfn + count))
     73                        conf = pfn;
     74                else
     75                        conf = minconf;
     76               
     77                zone_create(pfn, count, conf, 0);
     78               
     79                if (last_frame < ALIGN_UP(new_start + new_size, FRAME_SIZE))
     80                        last_frame = ALIGN_UP(new_start + new_size, FRAME_SIZE);
    8681        }
    87        
    88 }
    89 
    90 void frame_low_arch_init(void)
    91 {
    92         frame_common_arch_init(true);
    9382       
    9483        /* First is exception vector, second is 'implementation specific',
    … …  
    10392}
    10493
    105 void frame_high_arch_init(void)
    106 {
    107         frame_common_arch_init(false);
    108 }
    109 
    11094/** @}
    11195 */

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

    r7aaed09 r1761268  
    4646}
    4747
     48uintptr_t hw_map(uintptr_t physaddr, size_t size)
     49{
     50        if (last_frame + ALIGN_UP(size, PAGE_SIZE) >
     51            KA2PA(KERNEL_ADDRESS_SPACE_END_ARCH))
     52                panic("Unable to map physical memory %p (%zu bytes).",
     53                    (void *) physaddr, size);
     54       
     55        uintptr_t virtaddr = PA2KA(last_frame);
     56        pfn_t i;
     57        page_table_lock(AS_KERNEL, true);
     58        for (i = 0; i < ADDR2PFN(ALIGN_UP(size, PAGE_SIZE)); i++)
     59                page_mapping_insert(AS_KERNEL, virtaddr + PFN2ADDR(i),
     60                    physaddr + PFN2ADDR(i), PAGE_NOT_CACHEABLE | PAGE_WRITE);
     61        page_table_unlock(AS_KERNEL, true);
     62       
     63        last_frame = ALIGN_UP(last_frame + size, FRAME_SIZE);
     64       
     65        return virtaddr;
     66}
     67
    4868/** @}
    4969 */

  • kernel/arch/sparc64/Makefile.inc

    r7aaed09 r1761268  
    6868        arch/$(KARCH)/src/fpu_context.c \
    6969        arch/$(KARCH)/src/dummy.s \
    70         arch/$(KARCH)/src/mm/$(USARCH)/km.c \
    7170        arch/$(KARCH)/src/mm/$(USARCH)/as.c \
    7271        arch/$(KARCH)/src/mm/$(USARCH)/frame.c \

  • kernel/arch/sparc64/include/mm/sun4u/frame.h

    r7aaed09 r1761268  
    7272typedef union frame_address frame_address_t;
    7373
     74extern uintptr_t last_frame;
    7475extern uintptr_t end_of_identity;
    7576
    76 extern void frame_low_arch_init(void);
    77 extern void frame_high_arch_init(void);
     77extern void frame_arch_init(void);
    7878#define physmem_print()
    7979

  • kernel/arch/sparc64/include/mm/sun4v/frame.h

    r7aaed09 r1761268  
    4646#include <typedefs.h>
    4747
    48 extern void frame_low_arch_init(void);
    49 extern void frame_high_arch_init(void);
     48extern uintptr_t last_frame;
     49extern void frame_arch_init(void);
    5050#define physmem_print()
    5151

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

    r7aaed09 r1761268  
    5151}
    5252
     53/** Map memory-mapped device into virtual memory.
     54 *
     55 * We are currently using identity mapping for mapping device registers.
     56 *
     57 * @param physaddr Physical address of the page where the device is
     58 *                 located.
     59 * @param size     Size of the device's registers.
     60 *
     61 * @return Virtual address of the page where the device is mapped.
     62 *
     63 */
     64uintptr_t hw_map(uintptr_t physaddr, size_t size)
     65{
     66        return PA2KA(physaddr);
     67}
     68
    5369/** @}
    5470 */

  • kernel/arch/sparc64/src/mm/sun4u/frame.c

    r7aaed09 r1761268  
    4141#include <macros.h>
    4242
     43uintptr_t last_frame = (uintptr_t) NULL;
     44
    4345/** Create memory zones according to information stored in memmap.
    4446 *
    4547 * Walk the memory map and create frame zones according to it.
    4648 */
    47 static void frame_common_arch_init(bool low)
     49void frame_arch_init(void)
    4850{
    49         unsigned int i;
    50        
    51         for (i = 0; i < memmap.cnt; i++) {
    52                 uintptr_t base;
    53                 size_t size;
    54 
    55                 /*
    56                  * The memmap is created by HelenOS boot loader.
    57                  * It already contains no holes.
    58                  */
    59 
    60                 /* To be safe, make the available zone possibly smaller */
    61                 base = ALIGN_UP((uintptr_t) memmap.zones[i].start, FRAME_SIZE);
    62                 size = ALIGN_DOWN(memmap.zones[i].size -
    63                     (base - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
     51        if (config.cpu_active == 1) {
     52                unsigned int i;
    6453               
    65                 if (!frame_adjust_zone_bounds(low, &base, &size))
    66                         continue;
    67  
    68                 pfn_t confdata;
    69                 pfn_t pfn = ADDR2PFN(base);
    70                 size_t count = SIZE2FRAMES(size);
    71 
    72                 if (low) {
    73                         confdata = pfn;
     54                for (i = 0; i < memmap.cnt; i++) {
     55                        /* To be safe, make the available zone possibly smaller */
     56                        uintptr_t new_start = ALIGN_UP((uintptr_t) memmap.zones[i].start,
     57                            FRAME_SIZE);
     58                        size_t new_size = ALIGN_DOWN(memmap.zones[i].size -
     59                            (new_start - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
     60                       
     61                        /*
     62                         * The memmap is created by HelenOS boot loader.
     63                         * It already contains no holes.
     64                         */
     65                       
     66                        pfn_t confdata = ADDR2PFN(new_start);
     67                       
    7468                        if (confdata == ADDR2PFN(KA2PA(PFN2ADDR(0))))
    7569                                confdata = ADDR2PFN(KA2PA(PFN2ADDR(2)));
    7670                       
    77                         zone_create(pfn, count, confdata,
    78                             ZONE_AVAILABLE | ZONE_LOWMEM);
    79                 } else {
    80                         confdata = zone_external_conf_alloc(count);
    81                         zone_create(pfn, count, confdata,
    82                             ZONE_AVAILABLE | ZONE_HIGHMEM);
     71                        zone_create(ADDR2PFN(new_start), SIZE2FRAMES(new_size),
     72                            confdata, 0);
     73                       
     74                        last_frame = max(last_frame, new_start + new_size);
    8375                }
     76               
     77                /*
     78                 * On sparc64, physical memory can start on a non-zero address.
     79                 * The generic frame_init() only marks PFN 0 as not free, so we
     80                 * must mark the physically first frame not free explicitly
     81                 * here, no matter what is its address.
     82                 */
     83                frame_mark_unavailable(ADDR2PFN(KA2PA(PFN2ADDR(0))), 1);
    8484        }
    85                
    86 }
    87 
    88 void frame_low_arch_init(void)
    89 {
    90         if (config.cpu_active > 1)
    91                 return;
    9285       
    93         frame_common_arch_init(true);
    94        
    95         /*
    96          * On sparc64, physical memory can start on a non-zero address.
    97          * The generic frame_init() only marks PFN 0 as not free, so we
    98          * must mark the physically first frame not free explicitly
    99          * here, no matter what is its address.
    100          */
    101         frame_mark_unavailable(ADDR2PFN(KA2PA(PFN2ADDR(0))), 1);
    102 
    103         /* PA2KA will work only on low-memory. */
    104         end_of_identity = PA2KA(config.physmem_end - FRAME_SIZE) + PAGE_SIZE;
    105 }
    106 
    107 void frame_high_arch_init(void)
    108 {
    109         if (config.cpu_active > 1)
    110                 return;
    111 
    112         frame_common_arch_init(false);
     86        end_of_identity = PA2KA(last_frame);
    11387}
    11488

  • kernel/arch/sparc64/src/mm/sun4u/tlb.c

    r7aaed09 r1761268  
    206206        pte_t *t;
    207207
     208        page_table_lock(AS, true);
    208209        t = page_mapping_find(AS, page_16k, true);
    209210        if (t && PTE_EXECUTABLE(t)) {
    … …  
    217218                itsb_pte_copy(t, index);
    218219#endif
     220                page_table_unlock(AS, true);
    219221        } else {
    220222                /*
    … …  
    222224                 * handler.
    223225                 */
     226                page_table_unlock(AS, true);
    224227                if (as_page_fault(page_16k, PF_ACCESS_EXEC, istate) ==
    225228                    AS_PF_FAULT) {
    … …  
    247250        size_t index;
    248251        pte_t *t;
    249         as_t *as = AS;
    250252
    251253        page_8k = (uint64_t) tag.vpn << MMU_PAGE_WIDTH;
    … …  
    259261                            "Dereferencing NULL pointer.");
    260262                } else if (page_8k >= end_of_identity) {
    261                         /* Kernel non-identity. */
    262                         as = AS_KERNEL;
    263                 } else {
    264                         do_fast_data_access_mmu_miss_fault(istate, tag,
    265                     "Unexpected kernel page fault.");
     263                        /*
     264                         * The kernel is accessing the I/O space.
     265                         * We still do identity mapping for I/O,
     266                         * but without caching.
     267                         */
     268                        dtlb_insert_mapping(page_8k, KA2PA(page_8k),
     269                            PAGESIZE_8K, false, false);
     270                        return;
    266271                }
    267         }
    268 
    269         t = page_mapping_find(as, page_16k, true);
     272                do_fast_data_access_mmu_miss_fault(istate, tag, "Unexpected "
     273                    "kernel page fault.");
     274        }
     275
     276        page_table_lock(AS, true);
     277        t = page_mapping_find(AS, page_16k, true);
    270278        if (t) {
    271279                /*
    … …  
    278286                dtsb_pte_copy(t, index, true);
    279287#endif
     288                page_table_unlock(AS, true);
    280289        } else {
    281290                /*
    282291                 * Forward the page fault to the address space page fault
    283292                 * handler.
    284                  */
     293                 */             
     294                page_table_unlock(AS, true);
    285295                if (as_page_fault(page_16k, PF_ACCESS_READ, istate) ==
    286296                    AS_PF_FAULT) {
    … …  
    304314        size_t index;
    305315        pte_t *t;
    306         as_t *as = AS;
    307316
    308317        page_16k = ALIGN_DOWN((uint64_t) tag.vpn << MMU_PAGE_WIDTH, PAGE_SIZE);
    309318        index = tag.vpn % MMU_PAGES_PER_PAGE;   /* 16K-page emulation */
    310319
    311         if (tag.context == ASID_KERNEL)
    312                 as = AS_KERNEL;
    313 
    314         t = page_mapping_find(as, page_16k, true);
     320        page_table_lock(AS, true);
     321        t = page_mapping_find(AS, page_16k, true);
    315322        if (t && PTE_WRITABLE(t)) {
    316323                /*
    … …  
    327334                dtsb_pte_copy(t, index, false);
    328335#endif
     336                page_table_unlock(AS, true);
    329337        } else {
    330338                /*
    … …  
    332340                 * handler.
    333341                 */             
     342                page_table_unlock(AS, true);
    334343                if (as_page_fault(page_16k, PF_ACCESS_WRITE, istate) ==
    335344                    AS_PF_FAULT) {

  • kernel/arch/sparc64/src/mm/sun4v/frame.c

    r7aaed09 r1761268  
    4545 * Walk the memory map and create frame zones according to it.
    4646 */
    47 static void frame_common_arch_init(bool low)
     47void frame_arch_init(void)
    4848{
    49         unsigned int i;
     49        if (config.cpu_active == 1) {
     50                unsigned int i;
    5051               
    51         for (i = 0; i < memmap.cnt; i++) {
    52                 uintptr_t base;
    53                 size_t size;
    54 
    55                 /*
    56                  * The memmap is created by HelenOS boot loader.
    57                  * It already contains no holes.
    58                  */
    59 
    60                 /* To be safe, make the available zone possibly smaller */
    61                 base = ALIGN_UP((uintptr_t) memmap.zones[i].start, FRAME_SIZE);
    62                 size = ALIGN_DOWN(memmap.zones[i].size -
    63                     (base - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
    64                
    65                 if (!frame_adjust_zone_bounds(low, &base, &size))
    66                         continue;
    67 
    68                 pfn_t confdata;
    69                 pfn_t pfn = ADDR2PFN(base);
    70                 size_t count = SIZE2FRAMES(size);
    71 
    72                 if (low) {
    73                         confdata = pfn;
     52                for (i = 0; i < memmap.cnt; i++) {
     53                        /* To be safe, make the available zone possibly smaller */
     54                        uintptr_t new_start = ALIGN_UP((uintptr_t) memmap.zones[i].start,
     55                            FRAME_SIZE);
     56                        size_t new_size = ALIGN_DOWN(memmap.zones[i].size -
     57                            (new_start - ((uintptr_t) memmap.zones[i].start)), FRAME_SIZE);
     58                       
     59                        /*
     60                         * The memmap is created by HelenOS boot loader.
     61                         * It already contains no holes.
     62                         */
     63                       
     64                        pfn_t confdata = ADDR2PFN(new_start);
     65                       
    7466                        if (confdata == ADDR2PFN(KA2PA(PFN2ADDR(0))))
    7567                                confdata = ADDR2PFN(KA2PA(PFN2ADDR(2)));
    7668                       
    77                         zone_create(pfn, count, confdata,
    78                             ZONE_AVAILABLE | ZONE_LOWMEM);
    79                 } else {
    80                         confdata = zone_external_conf_alloc(count);
    81                         zone_create(pfn, count, confdata,
    82                             ZONE_AVAILABLE | ZONE_HIGHMEM);
     69                        zone_create(ADDR2PFN(new_start), SIZE2FRAMES(new_size),
     70                            confdata, 0);
    8371                }
     72               
     73                /*
     74                 * On sparc64, physical memory can start on a non-zero address.
     75                 * The generic frame_init() only marks PFN 0 as not free, so we
     76                 * must mark the physically first frame not free explicitly
     77                 * here, no matter what is its address.
     78                 */
     79                frame_mark_unavailable(ADDR2PFN(KA2PA(PFN2ADDR(0))), 1);
    8480        }
    85                
    86 }
    87 
    88 
    89 void frame_low_arch_init(void)
    90 {
    91         if (config.cpu_active > 1)
    92                 return;
    93 
    94         frame_common_arch_init(true);
    95 
    96         /*
    97          * On sparc64, physical memory can start on a non-zero address.
    98          * The generic frame_init() only marks PFN 0 as not free, so we
    99          * must mark the physically first frame not free explicitly
    100          * here, no matter what is its address.
    101          */
    102         frame_mark_unavailable(ADDR2PFN(KA2PA(PFN2ADDR(0))), 1);
    103 }
    104 
    105 void frame_high_arch_init(void)
    106 {
    107         if (config.cpu_active > 1)
    108                 return;
    109 
    110         frame_common_arch_init(false);
    11181}
    11282

  • kernel/arch/sparc64/src/mm/sun4v/tlb.c

    r7aaed09 r1761268  
    218218        pte_t *t;
    219219
     220        page_table_lock(AS, true);
    220221        t = page_mapping_find(AS, va, true);
    221222
    … …  
    230231                itsb_pte_copy(t);
    231232#endif
     233                page_table_unlock(AS, true);
    232234        } else {
    233235                /*
    … …  
    235237                 * handler.
    236238                 */
     239                page_table_unlock(AS, true);
    237240                if (as_page_fault(va, PF_ACCESS_EXEC, istate) == AS_PF_FAULT) {
    238241                        do_fast_instruction_access_mmu_miss_fault(istate,
    … …  
    271274        }
    272275
     276        page_table_lock(AS, true);
    273277        t = page_mapping_find(AS, va, true);
    274278        if (t) {
    … …  
    282286                dtsb_pte_copy(t, true);
    283287#endif
     288                page_table_unlock(AS, true);
    284289        } else {
    285290                /*
    … …  
    287292                 * handler.
    288293                 */             
     294                page_table_unlock(AS, true);
    289295                if (as_page_fault(va, PF_ACCESS_READ, istate) == AS_PF_FAULT) {
    290296                        do_fast_data_access_mmu_miss_fault(istate, page_and_ctx,
    … …  
    310316        uint16_t ctx = DMISS_CONTEXT(page_and_ctx);
    311317
     318        page_table_lock(AS, true);
    312319        t = page_mapping_find(AS, va, true);
    313320        if (t && PTE_WRITABLE(t)) {
    … …  
    324331                dtsb_pte_copy(t, false);
    325332#endif
     333                page_table_unlock(AS, true);
    326334        } else {
    327335                /*
    … …  
    329337                 * handler.
    330338                 */             
     339                page_table_unlock(AS, true);
    331340                if (as_page_fault(va, PF_ACCESS_WRITE, istate) == AS_PF_FAULT) {
    332341                        do_fast_data_access_protection_fault(istate, page_and_ctx,

  • kernel/genarch/include/mm/page_ht.h

    r7aaed09 r1761268  
    4343#include <mm/as.h>
    4444#include <mm/page.h>
    45 #include <mm/slab.h>
    4645#include <synch/mutex.h>
    4746#include <adt/hash_table.h>
    … …  
    6564extern page_mapping_operations_t ht_mapping_operations;
    6665
    67 extern slab_cache_t *pte_cache;
    6866extern mutex_t page_ht_lock;
    6967extern hash_table_t page_ht;

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

    r7aaed09 r1761268  
    4141#include <mm/as.h>
    4242#include <mm/frame.h>
    43 #include <mm/slab.h>
    4443#include <typedefs.h>
    4544#include <memstr.h>
    … …  
    7877                hash_table_create(&page_ht, PAGE_HT_ENTRIES, 2, &ht_operations);
    7978                mutex_initialize(&page_ht_lock, MUTEX_PASSIVE);
    80                 pte_cache = slab_cache_create("pte_cache", sizeof(pte_t), 0, NULL, NULL,
    81                     SLAB_CACHE_MAGDEFERRED);
    8279        }
    8380       

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

    r7aaed09 r1761268  
    7373pte_t *ptl0_create(unsigned int flags)
    7474{
    75         pte_t *dst_ptl0 = (pte_t *) frame_alloc(PTL0_SIZE,
    76             FRAME_LOWMEM | FRAME_KA);
     75        pte_t *dst_ptl0 = (pte_t *) frame_alloc(PTL0_SIZE, FRAME_KA);
    7776        size_t table_size = FRAME_SIZE << PTL0_SIZE;
    7877       
    … …  
    9089                    (pte_t *) PA2KA((uintptr_t) AS_KERNEL->genarch.page_table);
    9190               
    92                 uintptr_t src = (uintptr_t)
    93                     &src_ptl0[PTL0_INDEX(KERNEL_ADDRESS_SPACE_START)];
    94                 uintptr_t dst = (uintptr_t)
    95                     &dst_ptl0[PTL0_INDEX(KERNEL_ADDRESS_SPACE_START)];
     91                uintptr_t src =
     92                    (uintptr_t) &src_ptl0[PTL0_INDEX(KERNEL_ADDRESS_SPACE_START)];
     93                uintptr_t dst =
     94                    (uintptr_t) &dst_ptl0[PTL0_INDEX(KERNEL_ADDRESS_SPACE_START)];
    9695               
    9796                memsetb(dst_ptl0, table_size, 0);

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

    r7aaed09 r1761268  
    6060static pte_t *ht_mapping_find(as_t *, uintptr_t, bool);
    6161
    62 slab_cache_t *pte_cache = NULL;
    63 
    6462/**
    6563 * This lock protects the page hash table. It must be acquired
    … …  
    165163        pte_t *pte = hash_table_get_instance(item, pte_t, link);
    166164       
    167         slab_free(pte_cache, pte);
     165        free(pte);
    168166}
    169167
    … …  
    190188       
    191189        if (!hash_table_find(&page_ht, key)) {
    192                 pte_t *pte = slab_alloc(pte_cache, FRAME_LOWMEM | FRAME_ATOMIC);
     190                pte_t *pte = (pte_t *) malloc(sizeof(pte_t), FRAME_ATOMIC);
    193191                ASSERT(pte != NULL);
    194192               

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

    r7aaed09 r1761268  
    3939#include <mm/page.h>
    4040#include <mm/frame.h>
    41 #include <mm/km.h>
    4241#include <mm/as.h>
    4342#include <arch/mm/page.h>
    … …  
    7675       
    7776        if (GET_PTL1_FLAGS(ptl0, PTL0_INDEX(page)) & PAGE_NOT_PRESENT) {
    78                 pte_t *newpt = (pte_t *) frame_alloc(PTL1_SIZE,
    79                     FRAME_LOWMEM | FRAME_KA);
     77                pte_t *newpt = (pte_t *) frame_alloc(PTL1_SIZE, FRAME_KA);
    8078                memsetb(newpt, FRAME_SIZE << PTL1_SIZE, 0);
    8179                SET_PTL1_ADDRESS(ptl0, PTL0_INDEX(page), KA2PA(newpt));
    82                 SET_PTL1_FLAGS(ptl0, PTL0_INDEX(page),
    83                     PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE |
    84                     PAGE_WRITE);
     80                SET_PTL1_FLAGS(ptl0, PTL0_INDEX(page), PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE | PAGE_WRITE);
    8581        }
    8682       
    … …  
    8884       
    8985        if (GET_PTL2_FLAGS(ptl1, PTL1_INDEX(page)) & PAGE_NOT_PRESENT) {
    90                 pte_t *newpt = (pte_t *) frame_alloc(PTL2_SIZE,
    91                     FRAME_LOWMEM | FRAME_KA);
     86                pte_t *newpt = (pte_t *) frame_alloc(PTL2_SIZE, FRAME_KA);
    9287                memsetb(newpt, FRAME_SIZE << PTL2_SIZE, 0);
    9388                SET_PTL2_ADDRESS(ptl1, PTL1_INDEX(page), KA2PA(newpt));
    94                 SET_PTL2_FLAGS(ptl1, PTL1_INDEX(page),
    95                     PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE |
    96                     PAGE_WRITE);
     89                SET_PTL2_FLAGS(ptl1, PTL1_INDEX(page), PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE | PAGE_WRITE);
    9790        }
    9891       
    … …  
    10093       
    10194        if (GET_PTL3_FLAGS(ptl2, PTL2_INDEX(page)) & PAGE_NOT_PRESENT) {
    102                 pte_t *newpt = (pte_t *) frame_alloc(PTL3_SIZE,
    103                     FRAME_LOWMEM | FRAME_KA);
     95                pte_t *newpt = (pte_t *) frame_alloc(PTL3_SIZE, FRAME_KA);
    10496                memsetb(newpt, FRAME_SIZE << PTL3_SIZE, 0);
    10597                SET_PTL3_ADDRESS(ptl2, PTL2_INDEX(page), KA2PA(newpt));
    106                 SET_PTL3_FLAGS(ptl2, PTL2_INDEX(page),
    107                     PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE |
    108                     PAGE_WRITE);
     98                SET_PTL3_FLAGS(ptl2, PTL2_INDEX(page), PAGE_PRESENT | PAGE_USER | PAGE_EXEC | PAGE_CACHEABLE | PAGE_WRITE);
    10999        }
    110100       
    … …  
    154144       
    155145        /*
    156          * Second, free all empty tables along the way from PTL3 down to PTL0
    157          * except those needed for sharing the kernel non-identity mappings.
     146         * Second, free all empty tables along the way from PTL3 down to PTL0.
     147         *
    158148         */
    159149       
    … …  
    172162                /*
    173163                 * PTL3 is empty.
    174                  * Release the frame and remove PTL3 pointer from the parent
    175                  * table.
    176                  */
     164                 * Release the frame and remove PTL3 pointer from preceding table.
     165                 *
     166                 */
     167                frame_free(KA2PA((uintptr_t) ptl3));
    177168#if (PTL2_ENTRIES != 0)
    178169                memsetb(&ptl2[PTL2_INDEX(page)], sizeof(pte_t), 0);
    … …  
    180171                memsetb(&ptl1[PTL1_INDEX(page)], sizeof(pte_t), 0);
    181172#else
    182                 if (km_is_non_identity(page))
    183                         return;
    184 
    185173                memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
    186174#endif
    187                 frame_free(KA2PA((uintptr_t) ptl3));
    188175        } else {
    189176                /*
    … …  
    208195                /*
    209196                 * PTL2 is empty.
    210                  * Release the frame and remove PTL2 pointer from the parent
    211                  * table.
    212                  */
     197                 * Release the frame and remove PTL2 pointer from preceding table.
     198                 *
     199                 */
     200                frame_free(KA2PA((uintptr_t) ptl2));
    213201#if (PTL1_ENTRIES != 0)
    214202                memsetb(&ptl1[PTL1_INDEX(page)], sizeof(pte_t), 0);
    215203#else
    216                 if (km_is_non_identity(page))
    217                         return;
    218 
    219204                memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
    220205#endif
    221                 frame_free(KA2PA((uintptr_t) ptl2));
    222206        } else {
    223207                /*
    … …  
    243227                /*
    244228                 * PTL1 is empty.
    245                  * Release the frame and remove PTL1 pointer from the parent
    246                  * table.
    247                  */
    248                 if (km_is_non_identity(page))
    249                         return;
    250 
     229                 * Release the frame and remove PTL1 pointer from preceding table.
     230                 *
     231                 */
     232                frame_free(KA2PA((uintptr_t) ptl1));
    251233                memsetb(&ptl0[PTL0_INDEX(page)], sizeof(pte_t), 0);
    252                 frame_free(KA2PA((uintptr_t) ptl1));
    253234        }
    254235#endif /* PTL1_ENTRIES != 0 */

  • kernel/generic/include/align.h

    r7aaed09 r1761268  
    4242 *
    4343 * @param s Address or size to be aligned.
    44  * @param a Size of alignment, must be a power of 2.
     44 * @param a Size of alignment, must be power of 2.
    4545 */
    4646#define ALIGN_DOWN(s, a)  ((s) & ~((a) - 1))
    … …  
    5050 *
    5151 * @param s Address or size to be aligned.
    52  * @param a Size of alignment, must be a power of 2.
     52 * @param a Size of alignment, must be power of 2.
    5353 */
    5454#define ALIGN_UP(s, a)  (((s) + ((a) - 1)) & ~((a) - 1))
    55 
    56 /** Check alignment.
    57  *
    58  * @param s Address or size to be checked for alignment.
    59  * @param a Size of alignment, must be a power of 2.
    60  */
    61 #define IS_ALIGNED(s, a)        (ALIGN_UP((s), (a)) == (s))
    6255
    6356#endif

  • kernel/generic/include/config.h

    r7aaed09 r1761268  
    7474
    7575typedef struct {
    76         /** Number of processors detected. */
    77         unsigned int cpu_count;
    78         /** Number of processors that are up and running. */
    79         volatile size_t cpu_active;
     76        unsigned int cpu_count;      /**< Number of processors detected. */
     77        volatile size_t cpu_active;  /**< Number of processors that are up and running. */
    8078       
    8179        uintptr_t base;
    82         /** Size of memory in bytes taken by kernel and stack. */
    83         size_t kernel_size;
     80        size_t kernel_size;          /**< Size of memory in bytes taken by kernel and stack */
    8481       
    85         /** Base adddress of initial stack. */
    86         uintptr_t stack_base;
    87         /** Size of initial stack. */
    88         size_t stack_size;
    89 
    90         bool identity_configured;
    91         /** Base address of the kernel identity mapped memory. */
    92         uintptr_t identity_base;
    93         /** Size of the kernel identity mapped memory. */
    94         size_t identity_size;
    95 
    96         bool non_identity_configured;   
    97 
    98         /** End of physical memory. */
    99         uint64_t physmem_end;
     82        uintptr_t stack_base;        /**< Base adddress of initial stack */
     83        size_t stack_size;           /**< Size of initial stack */
    10084} config_t;
    10185

  • kernel/generic/include/macros.h

    r7aaed09 r1761268  
    7777#endif /* __ASM__ */
    7878
    79 #define ispwr2(x)       (((x) & ((x) - 1)) == 0)
    80 
    8179#define isdigit(d)     (((d) >= '0') && ((d) <= '9'))
    8280#define islower(c)     (((c) >= 'a') && ((c) <= 'z'))

  • kernel/generic/include/mm/frame.h

    r7aaed09 r1761268  
    5050typedef uint8_t frame_flags_t;
    5151
    52 #define FRAME_NONE        0x0
    5352/** Convert the frame address to kernel VA. */
    5453#define FRAME_KA          0x1
    … …  
    5958/** Do not reserve / unreserve memory. */
    6059#define FRAME_NO_RESERVE  0x8
    61 /** Allocate a frame which can be identity-mapped. */
    62 #define FRAME_LOWMEM      0x10
    63 /** Allocate a frame which cannot be identity-mapped. */
    64 #define FRAME_HIGHMEM     0x20
    6560
    6661typedef uint8_t zone_flags_t;
    6762
    68 #define ZONE_NONE       0x0
    6963/** Available zone (free for allocation) */
    70 #define ZONE_AVAILABLE  0x1
     64#define ZONE_AVAILABLE  0x0
    7165/** Zone is reserved (not available for allocation) */
    72 #define ZONE_RESERVED   0x2
     66#define ZONE_RESERVED   0x8
    7367/** Zone is used by firmware (not available for allocation) */
    74 #define ZONE_FIRMWARE   0x4
    75 /** Zone contains memory that can be identity-mapped */
    76 #define ZONE_LOWMEM     0x8
    77 /** Zone contains memory that cannot be identity-mapped */
    78 #define ZONE_HIGHMEM    0x10
     68#define ZONE_FIRMWARE   0x10
    7969
    80 /** Mask of zone bits that must be matched exactly. */
    81 #define ZONE_EF_MASK    0x7
    82 
    83 #define FRAME_TO_ZONE_FLAGS(ff) \
    84         ((((ff) & FRAME_LOWMEM) ? ZONE_LOWMEM : \
    85             (((ff) & FRAME_HIGHMEM) ? ZONE_HIGHMEM : ZONE_NONE)) | \
    86             (ZONE_AVAILABLE | ZONE_LOWMEM /* | ZONE_HIGHMEM */))
    87 
    88 #define ZONE_FLAGS_MATCH(zf, f) \
    89         (((((zf) & ZONE_EF_MASK)) == ((f) & ZONE_EF_MASK)) && \
    90             (((zf) & ~ZONE_EF_MASK) & (f)))
     70/** Currently there is no equivalent zone flags
     71    for frame flags */
     72#define FRAME_TO_ZONE_FLAGS(frame_flags)  0
    9173
    9274typedef struct {
    9375        size_t refcount;      /**< Tracking of shared frames */
     76        uint8_t buddy_order;  /**< Buddy system block order */
    9477        link_t buddy_link;    /**< Link to the next free block inside
    9578                                   one order */
    9679        void *parent;         /**< If allocated by slab, this points there */
    97         uint8_t buddy_order;  /**< Buddy system block order */
    9880} frame_t;
    9981
    … …  
    147129}
    148130
     131NO_TRACE static inline bool zone_flags_available(zone_flags_t flags)
     132{
     133        return ((flags & (ZONE_RESERVED | ZONE_FIRMWARE)) == 0);
     134}
     135
    149136#define IS_BUDDY_ORDER_OK(index, order) \
    150137    ((~(((sysarg_t) -1) << (order)) & (index)) == 0)
    … …  
    159146
    160147extern void frame_init(void);
    161 extern bool frame_adjust_zone_bounds(bool, uintptr_t *, size_t *);
    162148extern void *frame_alloc_generic(uint8_t, frame_flags_t, size_t *);
    163149extern void *frame_alloc(uint8_t, frame_flags_t);
    … …  
    175161extern void frame_mark_unavailable(pfn_t, size_t);
    176162extern size_t zone_conf_size(size_t);
    177 extern pfn_t zone_external_conf_alloc(size_t);
    178163extern bool zone_merge(size_t, size_t);
    179164extern void zone_merge_all(void);

  • kernel/generic/src/cpu/cpu.c

    r7aaed09 r1761268  
    7474                for (i = 0; i < config.cpu_count; i++) {
    7575                        cpus[i].stack = (uint8_t *) frame_alloc(STACK_FRAMES,
    76                             FRAME_LOWMEM | FRAME_KA | FRAME_ATOMIC);
     76                            FRAME_KA | FRAME_ATOMIC);
    7777                        cpus[i].id = i;
    7878                       

  • kernel/generic/src/main/main.c

    r7aaed09 r1761268  
    6868#include <mm/page.h>
    6969#include <genarch/mm/page_pt.h>
    70 #include <mm/km.h>
    7170#include <mm/tlb.h>
    7271#include <mm/as.h>
    … …  
    8988
    9089/** Global configuration structure. */
    91 config_t config = {
    92         .identity_configured = false,
    93         .non_identity_configured = false,
    94         .physmem_end = 0
    95 };
     90config_t config;
    9691
    9792/** Initial user-space tasks */
    … …  
    210205         */
    211206        arch_pre_mm_init();
    212         km_identity_init();
    213207        frame_init();
     208       
    214209        /* Initialize at least 1 memory segment big enough for slab to work. */
    215210        slab_cache_init();
    … …  
    219214        page_init();
    220215        tlb_init();
    221         km_non_identity_init();
    222216        ddi_init();
    223217        arch_post_mm_init();

  • kernel/generic/src/mm/frame.c

    r7aaed09 r1761268  
    240240NO_TRACE static bool zone_can_alloc(zone_t *zone, uint8_t order)
    241241{
    242         return ((zone->flags & ZONE_AVAILABLE) &&
    243             buddy_system_can_alloc(zone->buddy_system, order));
     242        return (zone_flags_available(zone->flags)
     243            && buddy_system_can_alloc(zone->buddy_system, order));
    244244}
    245245
    … …  
    265265                 * Check whether the zone meets the search criteria.
    266266                 */
    267                 if (ZONE_FLAGS_MATCH(zones.info[i].flags, flags)) {
     267                if ((zones.info[i].flags & flags) == flags) {
    268268                        /*
    269269                         * Check if the zone has 2^order frames area available.
    … …  
    460460NO_TRACE static pfn_t zone_frame_alloc(zone_t *zone, uint8_t order)
    461461{
    462         ASSERT(zone->flags & ZONE_AVAILABLE);
     462        ASSERT(zone_flags_available(zone->flags));
    463463       
    464464        /* Allocate frames from zone buddy system */
    … …  
    490490NO_TRACE static size_t zone_frame_free(zone_t *zone, size_t frame_idx)
    491491{
    492         ASSERT(zone->flags & ZONE_AVAILABLE);
     492        ASSERT(zone_flags_available(zone->flags));
    493493       
    494494        frame_t *frame = &zone->frames[frame_idx];
    … …  
    518518NO_TRACE static void zone_mark_unavailable(zone_t *zone, size_t frame_idx)
    519519{
    520         ASSERT(zone->flags & ZONE_AVAILABLE);
     520        ASSERT(zone_flags_available(zone->flags));
    521521       
    522522        frame_t *frame = zone_get_frame(zone, frame_idx);
    … …  
    549549    buddy_system_t *buddy)
    550550{
    551         ASSERT(zones.info[z1].flags & ZONE_AVAILABLE);
    552         ASSERT(zones.info[z2].flags & ZONE_AVAILABLE);
     551        ASSERT(zone_flags_available(zones.info[z1].flags));
     552        ASSERT(zone_flags_available(zones.info[z2].flags));
    553553        ASSERT(zones.info[z1].flags == zones.info[z2].flags);
    554554        ASSERT(zones.info[z1].base < zones.info[z2].base);
    … …  
    645645NO_TRACE static void return_config_frames(size_t znum, pfn_t pfn, size_t count)
    646646{
    647         ASSERT(zones.info[znum].flags & ZONE_AVAILABLE);
     647        ASSERT(zone_flags_available(zones.info[znum].flags));
    648648       
    649649        size_t cframes = SIZE2FRAMES(zone_conf_size(count));
    … …  
    681681    size_t count)
    682682{
    683         ASSERT(zones.info[znum].flags & ZONE_AVAILABLE);
     683        ASSERT(zone_flags_available(zones.info[znum].flags));
    684684        ASSERT(frame_idx + count < zones.info[znum].count);
    685685       
    … …  
    723723         * set of flags
    724724         */
    725         if ((z1 >= zones.count) || (z2 >= zones.count) || (z2 - z1 != 1) ||
    726             (zones.info[z1].flags != zones.info[z2].flags)) {
     725        if ((z1 >= zones.count) || (z2 >= zones.count)
     726            || (z2 - z1 != 1)
     727            || (!zone_flags_available(zones.info[z1].flags))
     728            || (!zone_flags_available(zones.info[z2].flags))
     729            || (zones.info[z1].flags != zones.info[z2].flags)) {
    727730                ret = false;
    728731                goto errout;
    … …  
    825828        zone->buddy_system = buddy;
    826829       
    827         if (flags & ZONE_AVAILABLE) {
     830        if (zone_flags_available(flags)) {
    828831                /*
    829832                 * Compute order for buddy system and initialize
    … …  
    862865{
    863866        return (count * sizeof(frame_t) + buddy_conf_size(fnzb(count)));
    864 }
    865 
    866 /** Allocate external configuration frames from low memory. */
    867 pfn_t zone_external_conf_alloc(size_t count)
    868 {
    869         size_t size = zone_conf_size(count);
    870         size_t order = ispwr2(size) ? fnzb(size) : (fnzb(size) + 1);
    871 
    872         return ADDR2PFN((uintptr_t) frame_alloc(order - FRAME_WIDTH, FRAME_LOWMEM));
    873867}
    874868
    … …  
    894888        irq_spinlock_lock(&zones.lock, true);
    895889       
    896         if (flags & ZONE_AVAILABLE) {  /* Create available zone */
     890        if (zone_flags_available(flags)) {  /* Create available zone */
    897891                /* Theoretically we could have NULL here, practically make sure
    898892                 * nobody tries to do that. If some platform requires, remove
    … …  
    900894                 */
    901895                ASSERT(confframe != ADDR2PFN((uintptr_t ) NULL));
    902 
    903                 /* Update the known end of physical memory. */
    904                 config.physmem_end = max(config.physmem_end, PFN2ADDR(start + count));
    905896               
    906897                /* If confframe is supposed to be inside our zone, then make sure
    … …  
    12411232       
    12421233        /* Tell the architecture to create some memory */
    1243         frame_low_arch_init();
     1234        frame_arch_init();
    12441235        if (config.cpu_active == 1) {
    12451236                frame_mark_unavailable(ADDR2PFN(KA2PA(config.base)),
    … …  
    12641255                frame_mark_unavailable(0, 1);
    12651256        }
    1266         frame_high_arch_init();
    1267 }
    1268 
    1269 /** Adjust bounds of physical memory region according to low/high memory split.
    1270  *
    1271  * @param low[in]       If true, the adujstment is performed to make the region
    1272  *                      fit in the low memory. Otherwise the adjustment is
    1273  *                      performed to make the region fit in the high memory.
    1274  * @param basep[inout]  Pointer to a variable which contains the region's base
    1275  *                      address and which may receive the adjusted base address.
    1276  * @param sizep[inout]  Pointer to a variable which contains the region's size
    1277  *                      and which may receive the adjusted size.
    1278  * @retun               True if the region still exists even after the
    1279  *                      adjustment, false otherwise.
    1280  */
    1281 bool frame_adjust_zone_bounds(bool low, uintptr_t *basep, size_t *sizep)
    1282 {
    1283         uintptr_t limit = config.identity_size;
    1284 
    1285         if (low) {
    1286                 if (*basep > limit)
    1287                         return false;
    1288                 if (*basep + *sizep > limit)
    1289                         *sizep = limit - *basep;
    1290         } else {
    1291                 if (*basep + *sizep <= limit)
    1292                         return false;
    1293                 if (*basep <= limit) {
    1294                         *sizep -= limit - *basep;
    1295                         *basep = limit;
    1296                 }
    1297         }
    1298         return true;
    12991257}
    13001258
    … …  
    13351293                *total += (uint64_t) FRAMES2SIZE(zones.info[i].count);
    13361294               
    1337                 if (zones.info[i].flags & ZONE_AVAILABLE) {
     1295                if (zone_flags_available(zones.info[i].flags)) {
    13381296                        *busy += (uint64_t) FRAMES2SIZE(zones.info[i].busy_count);
    13391297                        *free += (uint64_t) FRAMES2SIZE(zones.info[i].free_count);
    … …  
    13861344                irq_spinlock_unlock(&zones.lock, true);
    13871345               
    1388                 bool available = ((flags & ZONE_AVAILABLE) != 0);
     1346                bool available = zone_flags_available(flags);
    13891347               
    13901348                printf("%-4zu", i);
    … …  
    13981356#endif
    13991357               
    1400                 printf(" %12zu %c%c%c%c%c    ", count,
    1401                     available ? 'A' : '-',
    1402                     (flags & ZONE_RESERVED) ? 'R' : '-',
    1403                     (flags & ZONE_FIRMWARE) ? 'F' : '-',
    1404                     (flags & ZONE_LOWMEM) ? 'L' : '-',
    1405                     (flags & ZONE_HIGHMEM) ? 'H' : '-');
     1358                printf(" %12zu %c%c%c      ", count,
     1359                    available ? 'A' : ' ',
     1360                    (flags & ZONE_RESERVED) ? 'R' : ' ',
     1361                    (flags & ZONE_FIRMWARE) ? 'F' : ' ');
    14061362               
    14071363                if (available)
    … …  
    14451401        irq_spinlock_unlock(&zones.lock, true);
    14461402       
    1447         bool available = ((flags & ZONE_AVAILABLE) != 0);
     1403        bool available = zone_flags_available(flags);
    14481404       
    14491405        uint64_t size;
    … …  
    14551411        printf("Zone size:         %zu frames (%" PRIu64 " %s)\n", count,
    14561412            size, size_suffix);
    1457         printf("Zone flags:        %c%c%c%c%c\n",
    1458             available ? 'A' : '-',
    1459             (flags & ZONE_RESERVED) ? 'R' : '-',
    1460             (flags & ZONE_FIRMWARE) ? 'F' : '-',
    1461             (flags & ZONE_LOWMEM) ? 'L' : '-',
    1462             (flags & ZONE_HIGHMEM) ? 'H' : '-');
     1413        printf("Zone flags:        %c%c%c\n",
     1414            available ? 'A' : ' ',
     1415            (flags & ZONE_RESERVED) ? 'R' : ' ',
     1416            (flags & ZONE_FIRMWARE) ? 'F' : ' ');
    14631417       
    14641418        if (available) {

  • kernel/generic/src/mm/page.c

    r7aaed09 r1761268  
    6565#include <arch/mm/asid.h>
    6666#include <mm/as.h>
    67 #include <mm/km.h>
    6867#include <mm/frame.h>
    6968#include <arch/barrier.h>
    … …  
    178177}
    179178
    180 uintptr_t hw_map(uintptr_t physaddr, size_t size)
    181 {
    182         uintptr_t virtaddr;
    183         size_t asize;
    184         pfn_t i;
    185 
    186         asize = ALIGN_UP(size, PAGE_SIZE);
    187         virtaddr = km_page_alloc(asize, PAGE_SIZE);
    188 
    189         page_table_lock(AS_KERNEL, true);
    190         for (i = 0; i < ADDR2PFN(asize); i++) {
    191                 uintptr_t addr = PFN2ADDR(i);
    192                 page_mapping_insert(AS_KERNEL, virtaddr + addr, physaddr + addr,
    193                     PAGE_NOT_CACHEABLE | PAGE_WRITE);
    194         }
    195         page_table_unlock(AS_KERNEL, true);
    196        
    197         return virtaddr;
    198 }
    199 
    200179int page_find_mapping(uintptr_t virt, void **phys)
    201180{

  • kernel/generic/src/mm/reserve.c

    r7aaed09 r1761268  
    4242#include <typedefs.h>
    4343#include <arch/types.h>
    44 #include <debug.h>
    45 
    46 static bool reserve_initialized = false;
    4744
    4845IRQ_SPINLOCK_STATIC_INITIALIZE_NAME(reserve_lock, "reserve_lock");
    … …  
    5754{
    5855        reserve = frame_total_free_get();
    59         reserve_initialized = true;
    6056}
    6157
    … …  
    7167{
    7268        bool reserved = false;
    73 
    74         ASSERT(reserve_initialized);
    7569
    7670        irq_spinlock_lock(&reserve_lock, true);
    … …  
    117111void reserve_force_alloc(size_t size)
    118112{
    119         if (!reserve_initialized)
    120                 return;
    121 
    122113        irq_spinlock_lock(&reserve_lock, true);
    123114        reserve -= size;
    … …  
    131122void reserve_free(size_t size)
    132123{
    133         if (!reserve_initialized)
    134                 return;
    135 
    136124        irq_spinlock_lock(&reserve_lock, true);
    137125        reserve += size;

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

    r7aaed09 r1761268  
    173173#endif /* CONFIG_FPU */
    174174       
    175         /*
    176          * Allocate the kernel stack from the low-memory to prevent an infinite
    177          * nesting of TLB-misses when accessing the stack from the part of the
    178          * TLB-miss handler written in C.
    179          *
    180          * Note that low-memory is safe to be used for the stack as it will be
    181          * covered by the kernel identity mapping, which guarantees not to
    182          * nest TLB-misses infinitely (either via some hardware mechanism or
    183          * by the construciton of the assembly-language part of the TLB-miss
    184          * handler).
    185          *
    186          * This restriction can be lifted once each architecture provides
    187          * a similar guarantee, for example by locking the kernel stack
    188          * in the TLB whenever it is allocated from the high-memory and the
    189          * thread is being scheduled to run.
    190          */
    191         kmflags |= FRAME_LOWMEM;
    192         kmflags &= ~FRAME_HIGHMEM;
    193 
    194175        thread->kstack = (uint8_t *) frame_alloc(STACK_FRAMES, FRAME_KA | kmflags);
    195176        if (!thread->kstack) {
Note: See TracChangeset for help on using the changeset viewer.