Changeset mainline,1392


Ignore:
Timestamp:
01/27/2012 11:24:27 PM (4 months ago)
Author:
Jakub Jermar <jakub@…>
branch-nick:
HelenOS.mainline
parents:
RevTreeChgset
1391@mainline,1391[mainline,1391]
825.1.120@mainline,825.1.120[mainline,825.1.120]
revision id:
jakub@jermar.eu-20120127232427-f7m3ipwh413xgrlg
Message:

Merge from lp:~jakub/helenos/mm.

Location:
mainline/kernel
Files:
31 edited

Legend:

Unmodified
Added
Removed

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

    r1384 r1392  
    5757        size_t i; 
    5858        for (i = 0; i < init.cnt; i++) { 
    59                 init.tasks[i].addr = (uintptr_t) bootinfo->tasks[i].addr; 
     59                init.tasks[i].paddr = KA2PA(bootinfo->tasks[i].addr); 
    6060                init.tasks[i].size = bootinfo->tasks[i].size; 
    6161                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN, 

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

    r5.1.65 r.1.118  
    3838#include <arch/mm/page.h> 
    3939#include <mm/page.h> 
     40#include <mm/km.h> 
    4041#include <genarch/fb/fb.h> 
    4142#include <abi/fb/visuals.h> 
    … …  
    101102        s3c24xx_irqc_regs_t *irqc_regs; 
    102103 
    103         gta02_timer = (void *) hw_map(S3C24XX_TIMER_ADDRESS, PAGE_SIZE); 
    104         irqc_regs = (void *) hw_map(S3C24XX_IRQC_ADDRESS, PAGE_SIZE); 
     104        gta02_timer = (void *) km_map(S3C24XX_TIMER_ADDRESS, PAGE_SIZE, 
     105            PAGE_NOT_CACHEABLE); 
     106        irqc_regs = (void *) km_map(S3C24XX_IRQC_ADDRESS, PAGE_SIZE, 
     107            PAGE_NOT_CACHEABLE); 
    105108 
    106109        /* Initialize interrupt controller. */ 

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

    r5.1.65 r.1.118  
    4545#include <mm/page.h> 
    4646#include <mm/frame.h> 
     47#include <mm/km.h> 
    4748#include <arch/mm/frame.h> 
    4849#include <arch/mach/integratorcp/integratorcp.h> 
    … …  
    128129void icp_init(void) 
    129130{ 
    130         icp_hw_map.uart = hw_map(ICP_UART, PAGE_SIZE); 
    131         icp_hw_map.kbd_ctrl = hw_map(ICP_KBD, PAGE_SIZE); 
     131        icp_hw_map.uart = km_map(ICP_UART, PAGE_SIZE, 
     132            PAGE_WRITE | PAGE_NOT_CACHEABLE); 
     133        icp_hw_map.kbd_ctrl = km_map(ICP_KBD, PAGE_SIZE, PAGE_NOT_CACHEABLE); 
    132134        icp_hw_map.kbd_stat = icp_hw_map.kbd_ctrl + ICP_KBD_STAT; 
    133135        icp_hw_map.kbd_data = icp_hw_map.kbd_ctrl + ICP_KBD_DATA; 
    134136        icp_hw_map.kbd_intstat = icp_hw_map.kbd_ctrl + ICP_KBD_INTR_STAT; 
    135         icp_hw_map.rtc = hw_map(ICP_RTC, PAGE_SIZE); 
     137        icp_hw_map.rtc = km_map(ICP_RTC, PAGE_SIZE, 
     138            PAGE_WRITE | PAGE_NOT_CACHEABLE); 
    136139        icp_hw_map.rtc1_load = icp_hw_map.rtc + ICP_RTC1_LOAD_OFFSET; 
    137140        icp_hw_map.rtc1_read = icp_hw_map.rtc + ICP_RTC1_READ_OFFSET; 
    … …  
    141144        icp_hw_map.rtc1_intrstat = icp_hw_map.rtc + ICP_RTC1_INTRSTAT_OFFSET; 
    142145 
    143         icp_hw_map.irqc = hw_map(ICP_IRQC, PAGE_SIZE); 
     146        icp_hw_map.irqc = km_map(ICP_IRQC, PAGE_SIZE, 
     147            PAGE_WRITE | PAGE_NOT_CACHEABLE); 
    144148        icp_hw_map.irqc_mask = icp_hw_map.irqc + ICP_IRQC_MASK_OFFSET; 
    145149        icp_hw_map.irqc_unmask = icp_hw_map.irqc + ICP_IRQC_UNMASK_OFFSET; 
    146         icp_hw_map.cmcr = hw_map(ICP_CMCR, PAGE_SIZE); 
     150        icp_hw_map.cmcr = km_map(ICP_CMCR, PAGE_SIZE, 
     151            PAGE_WRITE | PAGE_NOT_CACHEABLE); 
    147152        icp_hw_map.sdramcr = icp_hw_map.cmcr + ICP_SDRAMCR_OFFSET; 
    148         icp_hw_map.vga = hw_map(ICP_VGA, PAGE_SIZE); 
     153        icp_hw_map.vga = km_map(ICP_VGA, PAGE_SIZE, 
     154            PAGE_WRITE | PAGE_NOT_CACHEABLE); 
    149155 
    150156        hw_map_init_called = true; 

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

    r5.1.65 r.1.118  
    3737#include <arch/mach/testarm/testarm.h> 
    3838#include <mm/page.h> 
     39#include <mm/km.h> 
    3940#include <genarch/fb/fb.h> 
    4041#include <abi/fb/visuals.h> 
    … …  
    7172void gxemul_init(void) 
    7273{ 
    73         gxemul_kbd = (void *) hw_map(GXEMUL_KBD_ADDRESS, PAGE_SIZE); 
    74         gxemul_rtc = (void *) hw_map(GXEMUL_RTC_ADDRESS, PAGE_SIZE); 
    75         gxemul_irqc = (void *) hw_map(GXEMUL_IRQC_ADDRESS, PAGE_SIZE); 
     74        gxemul_kbd = (void *) km_map(GXEMUL_KBD_ADDRESS, PAGE_SIZE, 
     75            PAGE_WRITE | PAGE_NOT_CACHEABLE); 
     76        gxemul_rtc = (void *) km_map(GXEMUL_RTC_ADDRESS, PAGE_SIZE, 
     77            PAGE_WRITE | PAGE_NOT_CACHEABLE); 
     78        gxemul_irqc = (void *) km_map(GXEMUL_IRQC_ADDRESS, PAGE_SIZE, 
     79            PAGE_WRITE | PAGE_NOT_CACHEABLE); 
    7680} 
    7781 

  • mainline/kernel/arch/ia32/src/smp/smp.c

    r1137 r.1.118  
    4747#include <debug.h> 
    4848#include <arch/asm.h> 
     49#include <mm/page.h> 
    4950#include <mm/frame.h> 
    50 #include <mm/page.h> 
     51#include <mm/km.h> 
    5152#include <mm/slab.h> 
    5253#include <mm/as.h> 
    … …  
    7273         
    7374        if (config.cpu_count > 1) { 
    74                 l_apic = (uint32_t *) hw_map((uintptr_t) l_apic, PAGE_SIZE); 
    75                 io_apic = (uint32_t *) hw_map((uintptr_t) io_apic, PAGE_SIZE); 
     75                l_apic = (uint32_t *) km_map((uintptr_t) l_apic, PAGE_SIZE, 
     76                    PAGE_WRITE | PAGE_NOT_CACHEABLE); 
     77                io_apic = (uint32_t *) km_map((uintptr_t) io_apic, PAGE_SIZE, 
     78                    PAGE_WRITE | PAGE_NOT_CACHEABLE); 
    7679        } 
    7780} 

  • mainline/kernel/arch/ia64/src/ia64.c

    r1385 r1392  
    5353#include <genarch/srln/srln.h> 
    5454#include <mm/page.h> 
     55#include <mm/km.h> 
    5556 
    5657#ifdef MACHINE_ski 
    … …  
    6970void arch_pre_main(void) 
    7071{ 
    71         init.cnt = min3(bootinfo->taskmap.cnt, TASKMAP_MAX_RECORDS, CONFIG_INIT_TASKS); 
     72        init.cnt = min3(bootinfo->taskmap.cnt, TASKMAP_MAX_RECORDS, 
     73            CONFIG_INIT_TASKS); 
    7274        size_t i; 
     75 
    7376        for (i = 0; i < init.cnt; i++) { 
    74                 init.tasks[i].addr = 
    75                     ((unsigned long) bootinfo->taskmap.tasks[i].addr) | 
    76                     VRN_MASK; 
     77                init.tasks[i].paddr = 
     78                    (uintptr_t) bootinfo->taskmap.tasks[i].addr; 
    7779                init.tasks[i].size = bootinfo->taskmap.tasks[i].size; 
    7880                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN, 
    … …  
    8789static void iosapic_init(void) 
    8890{ 
    89         uintptr_t IOSAPIC = hw_map(iosapic_base, PAGE_SIZE); 
     91        uintptr_t IOSAPIC = km_map(iosapic_base, PAGE_SIZE, 
     92            PAGE_WRITE | PAGE_NOT_CACHEABLE); 
    9093        int i; 
    9194         
    … …  
    115118        if (config.cpu_active == 1) { 
    116119                /* Map the page with legacy I/O. */ 
    117                 legacyio_virt_base = hw_map(LEGACYIO_PHYS_BASE, LEGACYIO_SIZE); 
     120                legacyio_virt_base = km_map(LEGACYIO_PHYS_BASE, LEGACYIO_SIZE, 
     121                    PAGE_WRITE | PAGE_NOT_CACHEABLE); 
    118122 
    119123                iosapic_init(); 

  • mainline/kernel/arch/mips32/src/mips32.c

    r32.1.2 r.1.115  
    7878        size_t i; 
    7979        for (i = 0; i < init.cnt; i++) { 
    80                 init.tasks[i].addr = (uintptr_t) bootinfo->tasks[i].addr; 
     80                init.tasks[i].paddr = KA2PA(bootinfo->tasks[i].addr); 
    8181                init.tasks[i].size = bootinfo->tasks[i].size; 
    8282                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN, 

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

    r1355 r.1.115  
    123123        for (i = 0; i < init.cnt; i++) 
    124124                if (overlaps(frame << ZERO_PAGE_WIDTH, ZERO_PAGE_SIZE, 
    125                     KA2PA(init.tasks[i].addr), init.tasks[i].size)) { 
     125                    init.tasks[i].paddr, init.tasks[i].size)) { 
    126126                        safe = false; 
    127127                        break; 

  • mainline/kernel/arch/mips64/src/mips64.c

    r32.1.2 r.1.116  
    7878        size_t i; 
    7979        for (i = 0; i < init.cnt; i++) { 
    80                 init.tasks[i].addr = (uintptr_t) bootinfo->tasks[i].addr; 
     80                init.tasks[i].paddr = KA2PA(bootinfo->tasks[i].addr); 
    8181                init.tasks[i].size = bootinfo->tasks[i].size; 
    8282                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN, 

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

    r1355 r.1.116  
    115115        for (i = 0; i < init.cnt; i++) 
    116116                if (overlaps(frame << ZERO_PAGE_WIDTH, ZERO_PAGE_SIZE, 
    117                     KA2PA(init.tasks[i].addr), init.tasks[i].size)) { 
     117                    init.tasks[i].paddr, init.tasks[i].size)) { 
    118118                        safe = false; 
    119119                        break; 

  • mainline/kernel/arch/ppc32/src/drivers/pic.c

    r486 r.1.118  
    3434 
    3535#include <arch/drivers/pic.h> 
    36 #include <mm/page.h> 
     36#include <mm/km.h> 
    3737#include <byteorder.h> 
    3838#include <bitops.h> 
    … …  
    4242void pic_init(uintptr_t base, size_t size, cir_t *cir, void **cir_arg) 
    4343{ 
    44         pic = (uint32_t *) hw_map(base, size); 
     44        pic = (uint32_t *) km_map(base, size, PAGE_WRITE | PAGE_NOT_CACHEABLE); 
    4545        *cir = pic_ack_interrupt; 
    4646        *cir_arg = NULL; 

  • mainline/kernel/arch/ppc32/src/ppc32.c

    r1137 r.1.118  
    4646#include <userspace.h> 
    4747#include <mm/page.h> 
     48#include <mm/km.h> 
    4849#include <abi/proc/uarg.h> 
    4950#include <console/console.h> 
    … …  
    7172        size_t i; 
    7273        for (i = 0; i < init.cnt; i++) { 
    73                 init.tasks[i].addr = (uintptr_t) bootinfo->taskmap.tasks[i].addr; 
     74                init.tasks[i].paddr = KA2PA(bootinfo->taskmap.tasks[i].addr); 
    7475                init.tasks[i].size = bootinfo->taskmap.tasks[i].size; 
    7576                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN, 
    … …  
    208209                size_t size = 2 * PAGE_SIZE; 
    209210                 
    210                 cuda_t *cuda = (cuda_t *) 
    211                     (hw_map(aligned_addr, offset + size) + offset); 
     211                cuda_t *cuda = (cuda_t *) (km_map(aligned_addr, offset + size, 
     212                    PAGE_WRITE | PAGE_NOT_CACHEABLE) + offset); 
    212213                 
    213214                /* Initialize I/O controller */ 

  • mainline/kernel/arch/sparc64/src/drivers/kbd.c

    r1079 r.1.118  
    4040#include <mm/page.h> 
    4141#include <arch/mm/page.h> 
     42#include <mm/km.h> 
    4243#include <typedefs.h> 
    4344#include <align.h> 
    … …  
    113114        size_t offset = pa - aligned_addr; 
    114115         
    115         ns16550_t *ns16550 = (ns16550_t *) 
    116            (hw_map(aligned_addr, offset + size) + offset); 
     116        ns16550_t *ns16550 = (ns16550_t *) (km_map(aligned_addr, offset + size, 
     117            PAGE_WRITE | PAGE_NOT_CACHEABLE) + offset); 
    117118         
    118119        ns16550_instance_t *ns16550_instance = ns16550_init(ns16550, inr, cir, cir_arg); 

  • mainline/kernel/arch/sparc64/src/drivers/pci.c

    r6.1.13 r.1.118  
    3939#include <genarch/ofw/upa.h> 
    4040#include <arch/trap/interrupt.h> 
    41 #include <mm/page.h> 
     41#include <mm/km.h> 
    4242#include <mm/slab.h> 
    4343#include <typedefs.h> 
    … …  
    109109        pci->model = PCI_SABRE; 
    110110        pci->op = &pci_sabre_ops; 
    111         pci->reg = (uint64_t *) hw_map(paddr, reg[SABRE_INTERNAL_REG].size); 
     111        pci->reg = (uint64_t *) km_map(paddr, reg[SABRE_INTERNAL_REG].size, 
     112            PAGE_WRITE | PAGE_NOT_CACHEABLE); 
    112113 
    113114        /* 
    … …  
    156157        pci->model = PCI_PSYCHO; 
    157158        pci->op = &pci_psycho_ops; 
    158         pci->reg = (uint64_t *) hw_map(paddr, reg[PSYCHO_INTERNAL_REG].size); 
     159        pci->reg = (uint64_t *) km_map(paddr, reg[PSYCHO_INTERNAL_REG].size, 
     160            PAGE_WRITE | PAGE_NOT_CACHEABLE); 
    159161 
    160162        /* 

  • mainline/kernel/arch/sparc64/src/sun4u/sparc64.c

    r56.1.1 r.1.115  
    6262        size_t i; 
    6363        for (i = 0; i < init.cnt; i++) { 
    64                 init.tasks[i].addr = (uintptr_t) bootinfo->taskmap.tasks[i].addr; 
     64                init.tasks[i].paddr = KA2PA(bootinfo->taskmap.tasks[i].addr); 
    6565                init.tasks[i].size = bootinfo->taskmap.tasks[i].size; 
    6666                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN, 

  • mainline/kernel/arch/sparc64/src/sun4v/sparc64.c

    r56.1.1 r.1.115  
    6464        size_t i; 
    6565        for (i = 0; i < init.cnt; i++) { 
    66                 init.tasks[i].addr = (uintptr_t) bootinfo->taskmap.tasks[i].addr; 
     66                init.tasks[i].paddr = KA2PA(bootinfo->taskmap.tasks[i].addr); 
    6767                init.tasks[i].size = bootinfo->taskmap.tasks[i].size; 
    6868                str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN, 

  • mainline/kernel/genarch/src/drivers/ega/ega.c

    r1064 r.1.118  
    3737#include <genarch/drivers/ega/ega.h> 
    3838#include <putchar.h> 
    39 #include <mm/page.h> 
     39#include <mm/km.h> 
    4040#include <mm/as.h> 
    4141#include <mm/slab.h> 
    42 #include <arch/mm/page.h> 
    4342#include <typedefs.h> 
    4443#include <arch/asm.h> 
    … …  
    598597         
    599598        instance->base = base; 
    600         instance->addr = (uint8_t *) hw_map(addr, EGA_VRAM_SIZE); 
     599        instance->addr = (uint8_t *) km_map(addr, EGA_VRAM_SIZE, 
     600            PAGE_WRITE | PAGE_NOT_CACHEABLE); 
    601601        if (!instance->addr) { 
    602602                LOG("Unable to EGA video memory."); 

  • mainline/kernel/genarch/src/drivers/s3c24xx_uart/s3c24xx_uart.c

    r1064 r.1.118  
    4545#include <mm/slab.h> 
    4646#include <mm/page.h> 
     47#include <mm/km.h> 
    4748#include <sysinfo/sysinfo.h> 
    4849#include <str.h> 
    … …  
    113114        uart_dev->data = uart; 
    114115 
    115         uart->io = (s3c24xx_uart_io_t *) hw_map(paddr, PAGE_SIZE); 
     116        uart->io = (s3c24xx_uart_io_t *) km_map(paddr, PAGE_SIZE, 
     117            PAGE_WRITE | PAGE_NOT_CACHEABLE); 
    116118        uart->indev = NULL; 
    117119 

  • mainline/kernel/genarch/src/fb/fb.c

    r1137 r.1.118  
    4040#include <console/console.h> 
    4141#include <sysinfo/sysinfo.h> 
    42 #include <mm/page.h> 
     42#include <mm/km.h> 
    4343#include <mm/slab.h> 
    4444#include <align.h> 
    … …  
    587587        size_t glyphsize = FONT_GLYPHS * instance->glyphbytes; 
    588588         
    589         instance->addr = (uint8_t *) hw_map((uintptr_t) props->addr, fbsize); 
     589        instance->addr = (uint8_t *) km_map((uintptr_t) props->addr, fbsize, 
     590            PAGE_WRITE | PAGE_NOT_CACHEABLE); 
    590591        if (!instance->addr) { 
    591592                LOG("Unable to map framebuffer."); 

  • mainline/kernel/genarch/src/multiboot/multiboot.c

    r1308 r.1.115  
    7777                        break; 
    7878                 
    79                 init.tasks[init.cnt].addr = PA2KA(mods[i].start); 
     79                init.tasks[init.cnt].paddr = mods[i].start; 
    8080                init.tasks[init.cnt].size = mods[i].end - mods[i].start; 
    8181                 

  • mainline/kernel/genarch/src/multiboot/multiboot2.c

    r1315 r.1.115  
    4545{ 
    4646        if (init.cnt < CONFIG_INIT_TASKS) { 
    47                 init.tasks[init.cnt].addr = PA2KA(module->start); 
     47                init.tasks[init.cnt].paddr = module->start; 
    4848                init.tasks[init.cnt].size = module->end - module->start; 
    4949                multiboot_extract_command(init.tasks[init.cnt].name, 

  • mainline/kernel/generic/include/config.h

    r5.1.74 r.1.115  
    5353 
    5454typedef struct { 
    55         uintptr_t addr; 
     55        uintptr_t paddr; 
    5656        size_t size; 
    5757        char name[CONFIG_TASK_NAME_BUFLEN]; 

  • mainline/kernel/generic/include/mm/km.h

    r.1.106 r.1.118  
    4949extern bool km_is_non_identity(uintptr_t); 
    5050 
     51extern uintptr_t km_map(uintptr_t, size_t, unsigned int); 
     52 
    5153extern uintptr_t km_temporary_page_get(uintptr_t *, frame_flags_t); 
    5254extern void km_temporary_page_put(uintptr_t); 

  • mainline/kernel/generic/include/mm/page.h

    r5.1.95 r.1.117  
    6666extern void map_structure(uintptr_t, size_t); 
    6767 
    68 extern uintptr_t hw_map(uintptr_t, size_t); 
    69  
    7068extern int page_find_mapping(uintptr_t, void **); 
    7169extern sysarg_t sys_page_find_mapping(uintptr_t, void *); 

  • mainline/kernel/generic/src/lib/rd.c

    r1306 r.1.115  
    5454void init_rd(void *data, size_t size) 
    5555{ 
    56         uintptr_t base = KA2PA((uintptr_t) data); 
     56        uintptr_t base = (uintptr_t) data; 
    5757        ASSERT((base % FRAME_SIZE) == 0); 
    5858         

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

    r1306 r.1.120  
    5757#include <mm/as.h> 
    5858#include <mm/frame.h> 
     59#include <mm/km.h> 
    5960#include <print.h> 
    6061#include <memstr.h> 
    … …  
    6869#include <str.h> 
    6970#include <sysinfo/stats.h> 
     71#include <align.h> 
    7072 
    7173#ifdef CONFIG_SMP 
    … …  
    178180         
    179181        for (i = 0; i < init.cnt; i++) { 
    180                 if (init.tasks[i].addr % FRAME_SIZE) { 
     182                if (init.tasks[i].paddr % FRAME_SIZE) { 
    181183                        printf("init[%zu]: Address is not frame aligned\n", i); 
    182184                        programs[i].task = NULL; 
    … …  
    199201                str_cpy(namebuf + INIT_PREFIX_LEN, 
    200202                    TASK_NAME_BUFLEN - INIT_PREFIX_LEN, name); 
    201                  
    202                 int rc = program_create_from_image((void *) init.tasks[i].addr, 
    203                     namebuf, &programs[i]); 
     203 
     204                /* 
     205                 * Create virtual memory mappings for init task images. 
     206                 */ 
     207                uintptr_t page = km_map(init.tasks[i].paddr, 
     208                    init.tasks[i].size, 
     209                    PAGE_READ | PAGE_WRITE | PAGE_CACHEABLE); 
     210                ASSERT(page); 
     211                 
     212                int rc = program_create_from_image((void *) page, namebuf, 
     213                    &programs[i]); 
    204214                 
    205215                if (rc == 0) { 
    … …  
    224234                         * Assume the last task is the RAM disk. 
    225235                         */ 
    226                         init_rd((void *) init.tasks[i].addr, init.tasks[i].size); 
     236                        init_rd((void *) init.tasks[i].paddr, init.tasks[i].size); 
    227237                } else 
    228238                        printf("init[%zu]: Init binary load failed (error %d)\n", i, rc); 

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

    r5.1.99 r.1.115  
    151151        size_t i; 
    152152        for (i = 0; i < init.cnt; i++) { 
    153                 if (PA_OVERLAPS(config.stack_base, config.stack_size, 
    154                     init.tasks[i].addr, init.tasks[i].size)) 
    155                         config.stack_base = ALIGN_UP(init.tasks[i].addr + 
    156                             init.tasks[i].size, config.stack_size); 
     153                if (overlaps(KA2PA(config.stack_base), config.stack_size, 
     154                    init.tasks[i].paddr, init.tasks[i].size)) { 
     155                        /* 
     156                         * The init task overlaps with the memory behind the 
     157                         * kernel image so it must be in low memory and we can 
     158                         * use PA2KA on the init task's physical address. 
     159                         */ 
     160                        config.stack_base = ALIGN_UP( 
     161                            PA2KA(init.tasks[i].paddr) + init.tasks[i].size, 
     162                            config.stack_size); 
     163                } 
    157164        } 
    158165         

  • mainline/kernel/generic/src/mm/backend_elf.c

    r.1.109 r.1.115  
    318318                        dirty = true; 
    319319                } else { 
    320                         frame = KA2PA(base + i * FRAME_SIZE); 
     320                        pte_t *pte = page_mapping_find(AS_KERNEL, 
     321                            base + i * FRAME_SIZE, true); 
     322 
     323                        ASSERT(pte); 
     324                        ASSERT(PTE_PRESENT(pte)); 
     325 
     326                        frame = PTE_GET_FRAME(pte); 
    321327                }        
    322328        } else if (upage >= start_anon) { 

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

    r1355 r.1.115  
    924924                                for (i = 0; i < init.cnt; i++) 
    925925                                        if (overlaps(addr, PFN2ADDR(confcount), 
    926                                             KA2PA(init.tasks[i].addr), 
     926                                            init.tasks[i].paddr, 
    927927                                            init.tasks[i].size)) { 
    928928                                                overlap = true; 
    … …  
    12511251                size_t i; 
    12521252                for (i = 0; i < init.cnt; i++) { 
    1253                         pfn_t pfn = ADDR2PFN(KA2PA(init.tasks[i].addr)); 
     1253                        pfn_t pfn = ADDR2PFN(init.tasks[i].paddr); 
    12541254                        frame_mark_unavailable(pfn, 
    12551255                            SIZE2FRAMES(init.tasks[i].size)); 

  • mainline/kernel/generic/src/mm/km.c

    r.1.106 r.1.119  
    4646#include <debug.h> 
    4747#include <arch.h> 
     48#include <align.h> 
     49#include <macros.h> 
     50#include <bitops.h> 
    4851 
    4952static ra_arena_t *km_ni_arena; 
    … …  
    120123        ra_free(km_ni_arena, page, size); 
    121124} 
     125 
     126uintptr_t km_map(uintptr_t paddr, size_t size, unsigned int flags) 
     127{ 
     128        uintptr_t vaddr; 
     129        size_t asize; 
     130        size_t align; 
     131        uintptr_t offs; 
     132 
     133        asize = ALIGN_UP(size, PAGE_SIZE); 
     134        align = ispwr2(size) ? size : (1U << (fnzb(size) + 1)); 
     135        vaddr = km_page_alloc(asize, max(PAGE_SIZE, align)); 
     136 
     137        page_table_lock(AS_KERNEL, true); 
     138        for (offs = 0; offs < asize; offs += PAGE_SIZE) { 
     139                page_mapping_insert(AS_KERNEL, vaddr + offs, paddr + offs, 
     140                    flags); 
     141        } 
     142        page_table_unlock(AS_KERNEL, true); 
     143         
     144        return vaddr; 
     145} 
     146 
    122147 
    123148/** Unmap kernen non-identity page. 
    … …  
    165190            FRAME_HIGHMEM | FRAME_ATOMIC | flags);  
    166191        if (frame) { 
    167                 page = km_page_alloc(PAGE_SIZE, PAGE_SIZE); 
     192                page = km_map(frame, PAGE_SIZE, 
     193                    PAGE_READ | PAGE_WRITE | PAGE_CACHEABLE); 
    168194                ASSERT(page);   // FIXME 
    169                 page_table_lock(AS_KERNEL, true); 
    170                 page_mapping_insert(AS_KERNEL, page, frame, 
    171                     PAGE_CACHEABLE | PAGE_READ | PAGE_WRITE); 
    172                 page_table_unlock(AS_KERNEL, true); 
    173195        } else { 
    174196                frame = (uintptr_t) frame_alloc_noreserve(ONE_FRAME, 

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

    r.1.102 r.1.117  
    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> 
    … …  
    7675#include <errno.h> 
    7776#include <align.h> 
    78 #include <macros.h> 
    79 #include <bitops.h> 
    8077 
    8178/** Virtual operations for page subsystem. */ 
    … …  
    193190} 
    194191 
    195 uintptr_t hw_map(uintptr_t physaddr, size_t size) 
    196 { 
    197         uintptr_t virtaddr; 
    198         size_t asize; 
    199         size_t align; 
    200         pfn_t i; 
    201  
    202         asize = ALIGN_UP(size, PAGE_SIZE); 
    203         align = ispwr2(size) ? size : (1U << (fnzb(size) + 1)); 
    204         virtaddr = km_page_alloc(asize, max(PAGE_SIZE, align)); 
    205  
    206         page_table_lock(AS_KERNEL, true); 
    207         for (i = 0; i < ADDR2PFN(asize); i++) { 
    208                 uintptr_t addr = PFN2ADDR(i); 
    209                 page_mapping_insert(AS_KERNEL, virtaddr + addr, physaddr + addr, 
    210                     PAGE_NOT_CACHEABLE | PAGE_WRITE); 
    211         } 
    212         page_table_unlock(AS_KERNEL, true); 
    213          
    214         return virtaddr; 
    215 } 
    216  
    217192int page_find_mapping(uintptr_t virt, void **phys) 
    218193{ 
Note: See TracChangeset for help on using the changeset viewer.