Changes in / [6be2c13:973be387] in mainline


Ignore:
Location:
kernel
Files:
45 edited

Legend:

Unmodified
Added
Removed

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

    r6be2c13 r973be387  
    9292        get_pt_flags((pte_t *) (ptl0), (size_t) (i))
    9393#define GET_PTL2_FLAGS_ARCH(ptl1, i) \
    94         0
     94        PAGE_PRESENT
    9595#define GET_PTL3_FLAGS_ARCH(ptl2, i) \
    96         0
     96        PAGE_PRESENT
    9797#define GET_FRAME_FLAGS_ARCH(ptl3, i) \
    9898        get_pt_flags((pte_t *) (ptl3), (size_t) (i))
    … …  
    154154        return (
    155155            ((unsigned int) (!p->page_cache_disable) << PAGE_CACHEABLE_SHIFT) |
    156             ((unsigned int) (!p->present) << PAGE_NOT_PRESENT_SHIFT) |
     156            ((unsigned int) (!p->present) << PAGE_PRESENT_SHIFT) |
    157157            ((unsigned int) p->uaccessible << PAGE_USER_SHIFT) |
     158            (1 << PAGE_READ_SHIFT) |
    158159            ((unsigned int) p->writeable << PAGE_WRITE_SHIFT) |
    159160            (1 << PAGE_EXEC_SHIFT) |

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

    r6be2c13 r973be387  
    212212
    213213        return ((!p->page_cache_disable) << PAGE_CACHEABLE_SHIFT |
    214             (!p->present) << PAGE_NOT_PRESENT_SHIFT |
     214            (!p->present) << PAGE_PRESENT_SHIFT |
    215215            p->uaccessible << PAGE_USER_SHIFT |
     216            1 << PAGE_READ_SHIFT |
    216217            p->writeable << PAGE_WRITE_SHIFT |
    217218            (!p->no_execute) << PAGE_EXEC_SHIFT |

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

    r6be2c13 r973be387  
    5656        uintptr_t cur;
    5757        unsigned int identity_flags =
    58             PAGE_GLOBAL | PAGE_CACHEABLE | PAGE_EXEC | PAGE_WRITE;
     58            PAGE_GLOBAL | PAGE_CACHEABLE | PAGE_EXEC | PAGE_WRITE | PAGE_READ;
    5959
    6060        page_mapping_operations = &pt_mapping_operations;

  • kernel/arch/amd64/src/vreg.c

    r6be2c13 r973be387  
    6767
    6868        page = (uint64_t *) km_map(frame, PAGE_SIZE,
    69             PAGE_WRITE | PAGE_USER | PAGE_CACHEABLE);
     69            PAGE_READ | PAGE_WRITE | PAGE_USER | PAGE_CACHEABLE);
    7070
    7171        write_msr(AMD_MSR_FS, (uintptr_t) page);

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

    r6be2c13 r973be387  
    108108        get_pt_level0_flags((pte_t *) (ptl0), (size_t) (i))
    109109#define GET_PTL2_FLAGS_ARCH(ptl1, i) \
    110         0
     110        PAGE_PRESENT
    111111#define GET_PTL3_FLAGS_ARCH(ptl2, i) \
    112         0
     112        PAGE_PRESENT
    113113#define GET_FRAME_FLAGS_ARCH(ptl3, i) \
    114114        get_pt_level1_flags((pte_t *) (ptl3), (size_t) (i))

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

    r6be2c13 r973be387  
    138138        int np = (p->descriptor_type == PTE_DESCRIPTOR_NOT_PRESENT);
    139139
    140         return (np << PAGE_NOT_PRESENT_SHIFT) | (1 << PAGE_USER_SHIFT) |
    141             (1 << PAGE_WRITE_SHIFT) |
     140        return (np << PAGE_PRESENT_SHIFT) | (1 << PAGE_USER_SHIFT) |
     141            (1 << PAGE_READ_SHIFT) | (1 << PAGE_WRITE_SHIFT) |
    142142            (1 << PAGE_EXEC_SHIFT) | (1 << PAGE_CACHEABLE_SHIFT);
    143143}
    … …  
    156156        int ap = p->access_permission_0;
    157157
    158         return ((dt == PTE_DESCRIPTOR_NOT_PRESENT) << PAGE_NOT_PRESENT_SHIFT) |
     158        return ((dt == PTE_DESCRIPTOR_NOT_PRESENT) << PAGE_PRESENT_SHIFT) |
     159            ((ap == PTE_AP_USER_RO_KERNEL_RW) << PAGE_READ_SHIFT) |
     160            ((ap == PTE_AP_USER_RW_KERNEL_RW) << PAGE_READ_SHIFT) |
    159161            ((ap == PTE_AP_USER_RW_KERNEL_RW) << PAGE_WRITE_SHIFT) |
    160162            ((ap != PTE_AP_USER_NO_KERNEL_RW) << PAGE_USER_SHIFT) |
     163            ((ap == PTE_AP_USER_NO_KERNEL_RW) << PAGE_READ_SHIFT) |
    161164            ((ap == PTE_AP_USER_NO_KERNEL_RW) << PAGE_WRITE_SHIFT) |
    162165            (1 << PAGE_EXEC_SHIFT) |
    … …  
    217220
    218221        if (flags & PAGE_USER)  {
     222                if (flags & PAGE_READ) {
     223                        p->access_permission_0 = p->access_permission_1 =
     224                            p->access_permission_2 = p->access_permission_3 =
     225                            PTE_AP_USER_RO_KERNEL_RW;
     226                }
    219227                if (flags & PAGE_WRITE) {
    220228                        p->access_permission_0 = p->access_permission_1 =
    221229                            p->access_permission_2 = p->access_permission_3 =
    222230                            PTE_AP_USER_RW_KERNEL_RW;
    223                 } else {
    224                         p->access_permission_0 = p->access_permission_1 =
    225                             p->access_permission_2 = p->access_permission_3 =
    226                             PTE_AP_USER_RO_KERNEL_RW;
    227231                }
    228232        }

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

    r6be2c13 r973be387  
    171171        const unsigned np = (p->descriptor_type == PTE_DESCRIPTOR_NOT_PRESENT);
    172172
    173         return (np << PAGE_NOT_PRESENT_SHIFT) | (1 << PAGE_USER_SHIFT) |
    174             (1 << PAGE_WRITE_SHIFT) |
     173        return (np << PAGE_PRESENT_SHIFT) | (1 << PAGE_USER_SHIFT) |
     174            (1 << PAGE_READ_SHIFT) | (1 << PAGE_WRITE_SHIFT) |
    175175            (1 << PAGE_EXEC_SHIFT) | (1 << PAGE_CACHEABLE_SHIFT);
    176176}
    … …  
    190190        const unsigned ap1 = p->access_permission_1;
    191191
    192         return ((dt == PTE_DESCRIPTOR_NOT_PRESENT) << PAGE_NOT_PRESENT_SHIFT) |
     192        return ((dt == PTE_DESCRIPTOR_NOT_PRESENT) << PAGE_PRESENT_SHIFT) |
    193193            ((dt != PTE_DESCRIPTOR_SMALL_PAGE_NX) << PAGE_EXEC_SHIFT) |
     194            ((ap0 == PTE_AP0_USER_LIMITED_KERNEL_FULL) << PAGE_READ_SHIFT) |
     195            ((ap0 == PTE_AP0_USER_FULL_KERNEL_FULL) << PAGE_READ_SHIFT) |
     196            ((ap0 == PTE_AP0_USER_NO_KERNEL_FULL) << PAGE_READ_SHIFT) |
    194197            ((ap0 != PTE_AP0_USER_NO_KERNEL_FULL) << PAGE_USER_SHIFT) |
    195198            (((ap1 != PTE_AP1_RO) && (ap0 == PTE_AP0_USER_FULL_KERNEL_FULL)) << PAGE_WRITE_SHIFT) |

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

    r6be2c13 r973be387  
    101101        beagleboard.irc_addr =
    102102            (void *) km_map(AMDM37x_IRC_BASE_ADDRESS, AMDM37x_IRC_SIZE,
    103             0);
     103            PAGE_NOT_CACHEABLE);
    104104        assert(beagleboard.irc_addr);
    105105        omap_irc_init(beagleboard.irc_addr);

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

    r6be2c13 r973be387  
    8787{
    8888        bbone.irc_addr = (void *) km_map(AM335x_IRC_BASE_ADDRESS,
    89             AM335x_IRC_SIZE, 0);
     89            AM335x_IRC_SIZE, PAGE_NOT_CACHEABLE);
    9090
    9191        bbone.cm_per_addr = (void *) km_map(AM335x_CM_PER_BASE_ADDRESS,
    92             AM335x_CM_PER_SIZE, 0);
     92            AM335x_CM_PER_SIZE, PAGE_NOT_CACHEABLE);
    9393
    9494        bbone.cm_dpll_addr = (void *) km_map(AM335x_CM_DPLL_BASE_ADDRESS,
    95             AM335x_CM_DPLL_SIZE, 0);
     95            AM335x_CM_DPLL_SIZE, PAGE_NOT_CACHEABLE);
    9696
    9797        bbone.ctrl_module = (void *) km_map(AM335x_CTRL_MODULE_BASE_ADDRESS,
    98             AM335x_CTRL_MODULE_SIZE, 0);
     98            AM335x_CTRL_MODULE_SIZE, PAGE_NOT_CACHEABLE);
    9999
    100100        assert(bbone.irc_addr != NULL);

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

    r6be2c13 r973be387  
    103103
    104104        gta02_timer = (void *) km_map(S3C24XX_TIMER_ADDRESS, PAGE_SIZE,
    105             0);
     105            PAGE_NOT_CACHEABLE);
    106106        irqc_regs = (void *) km_map(S3C24XX_IRQC_ADDRESS, PAGE_SIZE,
    107             0);
     107            PAGE_NOT_CACHEABLE);
    108108
    109109        /* Initialize interrupt controller. */

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

    r6be2c13 r973be387  
    135135{
    136136        icp.hw_map.uart = km_map(ICP_UART, PAGE_SIZE,
    137             PAGE_WRITE);
    138         icp.hw_map.kbd_ctrl = km_map(ICP_KBD, PAGE_SIZE, 0);
     137            PAGE_WRITE | PAGE_NOT_CACHEABLE);
     138        icp.hw_map.kbd_ctrl = km_map(ICP_KBD, PAGE_SIZE, PAGE_NOT_CACHEABLE);
    139139        icp.hw_map.kbd_stat = icp.hw_map.kbd_ctrl + ICP_KBD_STAT;
    140140        icp.hw_map.kbd_data = icp.hw_map.kbd_ctrl + ICP_KBD_DATA;
    141141        icp.hw_map.kbd_intstat = icp.hw_map.kbd_ctrl + ICP_KBD_INTR_STAT;
    142142        icp.hw_map.rtc = km_map(ICP_RTC, PAGE_SIZE,
    143             PAGE_WRITE);
     143            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    144144        icp.hw_map.rtc1_load = icp.hw_map.rtc + ICP_RTC1_LOAD_OFFSET;
    145145        icp.hw_map.rtc1_read = icp.hw_map.rtc + ICP_RTC1_READ_OFFSET;
    … …  
    150150
    151151        icp.hw_map.irqc = km_map(ICP_IRQC, PAGE_SIZE,
    152             PAGE_WRITE);
     152            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    153153        icp.hw_map.irqc_mask = icp.hw_map.irqc + ICP_IRQC_MASK_OFFSET;
    154154        icp.hw_map.irqc_unmask = icp.hw_map.irqc + ICP_IRQC_UNMASK_OFFSET;
    155155        icp.hw_map.cmcr = km_map(ICP_CMCR, PAGE_SIZE,
    156             PAGE_WRITE);
     156            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    157157        icp.hw_map.sdramcr = icp.hw_map.cmcr + ICP_SDRAMCR_OFFSET;
    158158        icp.hw_map.vga = km_map(ICP_VGA, PAGE_SIZE,
    159             PAGE_WRITE);
     159            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    160160
    161161        hw_map_init_called = true;

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

    r6be2c13 r973be387  
    102102        /* Initialize interrupt controller */
    103103        raspi.irc = (void *) km_map(BCM2835_IRC_ADDR, sizeof(bcm2835_irc_t),
    104                                     0);
     104                                    PAGE_NOT_CACHEABLE);
    105105        assert(raspi.irc);
    106106        bcm2835_irc_init(raspi.irc);
    … …  
    109109        raspi.timer = (void *) km_map(BCM2835_TIMER_ADDR,
    110110                                      sizeof(bcm2835_timer_t),
    111                                       0);
     111                                      PAGE_NOT_CACHEABLE);
    112112}
    113113

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

    r6be2c13 r973be387  
    5757
    5858        ras_page = (uintptr_t *) km_map(frame,
    59             PAGE_SIZE, PAGE_WRITE | PAGE_USER | PAGE_CACHEABLE);
     59            PAGE_SIZE, PAGE_READ | PAGE_WRITE | PAGE_USER | PAGE_CACHEABLE);
    6060
    6161        memsetb(ras_page, PAGE_SIZE, 0);

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

    r6be2c13 r973be387  
    109109        get_pt_flags((pte_t *) (ptl0), (size_t) (i))
    110110#define GET_PTL2_FLAGS_ARCH(ptl1, i) \
    111         0
     111        PAGE_PRESENT
    112112#define GET_PTL3_FLAGS_ARCH(ptl2, i) \
    113         0
     113        PAGE_PRESENT
    114114#define GET_FRAME_FLAGS_ARCH(ptl3, i) \
    115115        get_pt_flags((pte_t *) (ptl3), (size_t) (i))
    … …  
    185185
    186186        return ((!p->page_cache_disable) << PAGE_CACHEABLE_SHIFT |
    187             (!p->present) << PAGE_NOT_PRESENT_SHIFT |
     187            (!p->present) << PAGE_PRESENT_SHIFT |
    188188            p->uaccessible << PAGE_USER_SHIFT |
     189            1 << PAGE_READ_SHIFT |
    189190            p->writeable << PAGE_WRITE_SHIFT |
    190191            1 << PAGE_EXEC_SHIFT |

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

    r6be2c13 r973be387  
    7070        for (cur = 0; cur < min(config.identity_size, config.physmem_end);
    7171            cur += FRAME_SIZE) {
    72                 flags = PAGE_GLOBAL | PAGE_CACHEABLE | PAGE_WRITE;
     72                flags = PAGE_GLOBAL | PAGE_CACHEABLE | PAGE_WRITE | PAGE_READ;
    7373                page_mapping_insert(AS_KERNEL, PA2KA(cur), cur, flags);
    7474        }

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

    r6be2c13 r973be387  
    7575
    7676        if (config.cpu_count > 1) {
    77                 l_apic = (uint32_t *) km_map((uintptr_t) l_apic,
    78                     PAGE_SIZE, PAGE_WRITE);
    79                 io_apic = (uint32_t *) km_map((uintptr_t) io_apic,
    80                     PAGE_SIZE, PAGE_WRITE);
     77                l_apic = (uint32_t *) km_map((uintptr_t) l_apic, PAGE_SIZE,
     78                    PAGE_WRITE | PAGE_NOT_CACHEABLE);
     79                io_apic = (uint32_t *) km_map((uintptr_t) io_apic, PAGE_SIZE,
     80                    PAGE_WRITE | PAGE_NOT_CACHEABLE);
    8181        }
    8282}

  • kernel/arch/ia32/src/vreg.c

    r6be2c13 r973be387  
    6868
    6969        page = (uint32_t *) km_map(frame, PAGE_SIZE,
    70             PAGE_WRITE | PAGE_USER | PAGE_CACHEABLE);
     70            PAGE_READ | PAGE_WRITE | PAGE_USER | PAGE_CACHEABLE);
    7171
    7272        gdt_setbase(&gdt_p[VREG_DES], (uintptr_t) page);

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

    r6be2c13 r973be387  
    106106{
    107107        uintptr_t IOSAPIC = km_map(iosapic_base, PAGE_SIZE,
    108             PAGE_WRITE);
     108            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    109109        int i;
    110110
    … …  
    135135                /* Map the page with legacy I/O. */
    136136                legacyio_virt_base = km_map(LEGACYIO_PHYS_BASE, LEGACYIO_SIZE,
    137                     PAGE_WRITE);
     137                    PAGE_WRITE | PAGE_NOT_CACHEABLE);
    138138
    139139                iosapic_init();

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

    r6be2c13 r973be387  
    114114        get_pt_flags((pte_t *) (ptl0), (size_t) (i))
    115115#define GET_PTL2_FLAGS_ARCH(ptl1, i) \
    116         0
     116        PAGE_PRESENT
    117117#define GET_PTL3_FLAGS_ARCH(ptl2, i) \
    118         0
     118        PAGE_PRESENT
    119119#define GET_FRAME_FLAGS_ARCH(ptl3, i) \
    120120        get_pt_flags((pte_t *) (ptl3), (size_t) (i))
    … …  
    167167
    168168        return ((p->cacheable << PAGE_CACHEABLE_SHIFT) |
    169             ((!p->p) << PAGE_NOT_PRESENT_SHIFT) |
     169            ((!p->p) << PAGE_PRESENT_SHIFT) |
    170170            (1 << PAGE_USER_SHIFT) |
     171            (1 << PAGE_READ_SHIFT) |
    171172            ((p->w) << PAGE_WRITE_SHIFT) |
    172173            (1 << PAGE_EXEC_SHIFT) |

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

    r6be2c13 r973be387  
    111111
    112112#define GET_PTL2_FLAGS_ARCH(ptl1, i) \
    113         0
     113        PAGE_PRESENT
    114114
    115115#define GET_PTL3_FLAGS_ARCH(ptl2, i) \
    116         0
     116        PAGE_PRESENT
    117117
    118118#define GET_FRAME_FLAGS_ARCH(ptl3, i) \
    … …  
    167167
    168168        return (((!entry->page_cache_disable) << PAGE_CACHEABLE_SHIFT) |
    169             ((!entry->present) << PAGE_NOT_PRESENT_SHIFT) |
     169            ((!entry->present) << PAGE_PRESENT_SHIFT) |
    170170            (1 << PAGE_USER_SHIFT) |
     171            (1 << PAGE_READ_SHIFT) |
    171172            (1 << PAGE_WRITE_SHIFT) |
    172173            (1 << PAGE_EXEC_SHIFT) |

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

    r6be2c13 r973be387  
    4242void pic_init(uintptr_t base, size_t size, cir_t *cir, void **cir_arg)
    4343{
    44         pic = (uint32_t *) km_map(base, size, PAGE_WRITE);
     44        pic = (uint32_t *) km_map(base, size, PAGE_WRITE | PAGE_NOT_CACHEABLE);
    4545        *cir = pic_ack_interrupt;
    4646        *cir_arg = NULL;

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

    r6be2c13 r973be387  
    242242
    243243                cuda_t *cuda = (cuda_t *) (km_map(aligned_addr, offset + size,
    244                     PAGE_WRITE) + offset);
     244                    PAGE_WRITE | PAGE_NOT_CACHEABLE) + offset);
    245245
    246246                /* Initialize I/O controller */

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

    r6be2c13 r973be387  
    8282
    8383/* Flags mask for non-leaf page table entries */
    84 #define NON_LEAF_MASK  (~(PAGE_WRITE | PAGE_EXEC))
     84#define NON_LEAF_MASK  (~(PAGE_READ | PAGE_WRITE | PAGE_EXEC))
    8585
    8686/* Get PTE address accessors for each level. */
    … …  
    183183        pte_t *entry = &pt[i];
    184184
    185         return (((!entry->valid) << PAGE_NOT_PRESENT_SHIFT) |
     185        return (((!entry->valid) << PAGE_PRESENT_SHIFT) |
    186186            (entry->user << PAGE_USER_SHIFT) |
     187            (entry->readable << PAGE_READ_SHIFT) |
    187188            (entry->writable << PAGE_WRITE_SHIFT) |
    188189            (entry->executable << PAGE_EXEC_SHIFT) |
    … …  
    195196
    196197        entry->valid = !(flags & PAGE_NOT_PRESENT);
    197         entry->readable = 1;
     198        entry->readable = (flags & PAGE_READ) != 0;
    198199        entry->writable = (flags & PAGE_WRITE) != 0;
    199200        entry->executable = (flags & PAGE_EXEC) != 0;

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

    r6be2c13 r973be387  
    6363                    cur += FRAME_SIZE)
    6464                        page_mapping_insert(AS_KERNEL, PA2KA(cur), cur,
    65                             PAGE_GLOBAL | PAGE_CACHEABLE | PAGE_EXEC | PAGE_WRITE);
     65                            PAGE_GLOBAL | PAGE_CACHEABLE | PAGE_EXEC | PAGE_WRITE | PAGE_READ);
    6666
    6767                page_table_unlock(AS_KERNEL, true);

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

    r6be2c13 r973be387  
    119119
    120120        ioport8_t *ns16550 = (ioport8_t *) (km_map(aligned_addr, offset + size,
    121             PAGE_WRITE) + offset);
     121            PAGE_WRITE | PAGE_NOT_CACHEABLE) + offset);
    122122
    123123        ns16550_instance_t *ns16550_instance = ns16550_init(ns16550, 0, inr, cir,

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

    r6be2c13 r973be387  
    110110        pci->op = &pci_sabre_ops;
    111111        pci->reg = (uint64_t *) km_map(paddr, reg[SABRE_INTERNAL_REG].size,
    112             PAGE_WRITE);
     112            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    113113
    114114        return pci;
    … …  
    152152        pci->op = &pci_psycho_ops;
    153153        pci->reg = (uint64_t *) km_map(paddr, reg[PSYCHO_INTERNAL_REG].size,
    154             PAGE_WRITE);
     154            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    155155
    156156        return pci;

  • kernel/genarch/include/genarch/drivers/amdm37x/gpt.h

    r6be2c13 r973be387  
    208208        // TODO find a nicer way to setup 32kHz clock source for timer1
    209209        // reg 0x48004C40 is CM_CLKSEL_WKUP see page 485 of the manual
    210         ioport32_t *clksel = (void*) km_map(0x48004C40, 4, 0);
     210        ioport32_t *clksel = (void*) km_map(0x48004C40, 4, PAGE_NOT_CACHEABLE);
    211211        *clksel &= ~1;
    212212        km_unmap((uintptr_t)clksel, 4);
    … …  
    214214        assert(timer);
    215215        /* Map control register */
    216         timer->regs = (void*) km_map(ioregs, iosize, 0);
     216        timer->regs = (void*) km_map(ioregs, iosize, PAGE_NOT_CACHEABLE);
    217217
    218218        /* Reset the timer */

  • kernel/genarch/src/acpi/acpi.c

    r6be2c13 r973be387  
    104104        /* Start with mapping the header only. */
    105105        vhdr = (struct acpi_sdt_header *) km_map((uintptr_t) psdt,
    106             sizeof(struct acpi_sdt_header), 0);
     106            sizeof(struct acpi_sdt_header), PAGE_READ | PAGE_NOT_CACHEABLE);
    107107
    108108        /* Now we can map the entire structure. */
    109109        vsdt = (struct acpi_sdt_header *) km_map((uintptr_t) psdt,
    110             vhdr->length, PAGE_WRITE);
     110            vhdr->length, PAGE_WRITE | PAGE_NOT_CACHEABLE);
    111111
    112112        // TODO: do not leak vtmp

  • kernel/genarch/src/drivers/am335x/timer.c

    r6be2c13 r973be387  
    100100        size = regs_map[id].size;
    101101
    102         timer->regs = (void *) km_map(base_addr, size, 0);
     102        timer->regs = (void *) km_map(base_addr, size, PAGE_NOT_CACHEABLE);
    103103        assert(timer->regs != NULL);
    104104

  • kernel/genarch/src/drivers/bcm2835/mbox.c

    r6be2c13 r973be387  
    9191
    9292        fb_mbox = (void *) km_map(BCM2835_MBOX0_ADDR, sizeof(bcm2835_mbox_t),
    93                                   0);
     93                                  PAGE_NOT_CACHEABLE);
    9494
    9595        fb_desc->width = 640;

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

    r6be2c13 r973be387  
    601601        instance->base = base;
    602602        instance->addr = (uint8_t *) km_map(addr, EGA_VRAM_SIZE,
    603             PAGE_WRITE);
     603            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    604604        if (!instance->addr) {
    605605                LOG("Unable to EGA video memory.");

  • kernel/genarch/src/drivers/omap/uart.c

    r6be2c13 r973be387  
    8787{
    8888        assert(uart);
    89         uart->regs = (void *)km_map(addr, size, 0);
     89        uart->regs = (void *)km_map(addr, size, PAGE_NOT_CACHEABLE);
    9090
    9191        assert(uart->regs);

  • kernel/genarch/src/drivers/pl011/pl011.c

    r6be2c13 r973be387  
    100100        assert(uart);
    101101        uart->regs = (void*)km_map(addr, sizeof(pl011_uart_regs_t),
    102                                    0);
     102                                   PAGE_NOT_CACHEABLE);
    103103        assert(uart->regs);
    104104

  • kernel/genarch/src/drivers/s3c24xx/uart.c

    r6be2c13 r973be387  
    117117
    118118        uart->io = (s3c24xx_uart_io_t *) km_map(paddr, PAGE_SIZE,
    119             PAGE_WRITE);
     119            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    120120        uart->indev = NULL;
    121121

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

    r6be2c13 r973be387  
    610610
    611611        instance->addr = (uint8_t *) km_map((uintptr_t) props->addr, fbsize,
    612             PAGE_WRITE);
     612            PAGE_WRITE | PAGE_NOT_CACHEABLE);
    613613        if (!instance->addr) {
    614614                LOG("Unable to map framebuffer.");

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

    r6be2c13 r973be387  
    6161static void ht_mapping_remove(as_t *, uintptr_t);
    6262static bool ht_mapping_find(as_t *, uintptr_t, bool, pte_t *);
    63 static void ht_mapping_update(as_t *, uintptr_t, bool, const pte_t *);
     63static void ht_mapping_update(as_t *, uintptr_t, bool, pte_t *);
    6464static void ht_mapping_make_global(uintptr_t, size_t);
    6565
    … …  
    268268 * @param pte      New PTE.
    269269 */
    270 void ht_mapping_update(as_t *as, uintptr_t page, bool nolock, const pte_t *pte)
     270void ht_mapping_update(as_t *as, uintptr_t page, bool nolock, pte_t *pte)
    271271{
    272272        irq_spinlock_lock(&page_ht_lock, true);

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

    r6be2c13 r973be387  
    5555static void pt_mapping_remove(as_t *, uintptr_t);
    5656static bool pt_mapping_find(as_t *, uintptr_t, bool, pte_t *pte);
    57 static void pt_mapping_update(as_t *, uintptr_t, bool, const pte_t *pte);
     57static void pt_mapping_update(as_t *, uintptr_t, bool, pte_t *pte);
    5858static void pt_mapping_make_global(uintptr_t, size_t);
    5959
    … …  
    353353 * @param[in] pte  New PTE.
    354354 */
    355 void pt_mapping_update(as_t *as, uintptr_t page, bool nolock, const pte_t *pte)
     355void pt_mapping_update(as_t *as, uintptr_t page, bool nolock, pte_t *pte)
    356356{
    357357        pte_t *t = pt_mapping_find_internal(as, page, nolock);
    … …  
    431431                SET_PTL1_ADDRESS(ptl0, PTL0_INDEX(addr), KA2PA(l1));
    432432                SET_PTL1_FLAGS(ptl0, PTL0_INDEX(addr),
    433                     PAGE_USER | PAGE_CACHEABLE |
    434                     PAGE_EXEC | PAGE_WRITE);
     433                    PAGE_PRESENT | PAGE_USER | PAGE_CACHEABLE |
     434                    PAGE_EXEC | PAGE_WRITE | PAGE_READ);
    435435        }
    436436}

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

    r6be2c13 r973be387  
    3737
    3838#define PAGE_CACHEABLE_SHIFT            0
    39 #define PAGE_NOT_PRESENT_SHIFT          1
     39#define PAGE_NOT_CACHEABLE_SHIFT        PAGE_CACHEABLE_SHIFT
     40#define PAGE_PRESENT_SHIFT              1
     41#define PAGE_NOT_PRESENT_SHIFT          PAGE_PRESENT_SHIFT
    4042#define PAGE_USER_SHIFT                 2
     43#define PAGE_KERNEL_SHIFT               PAGE_USER_SHIFT
     44#define PAGE_READ_SHIFT                 3
    4145#define PAGE_WRITE_SHIFT                4
    4246#define PAGE_EXEC_SHIFT                 5
    4347#define PAGE_GLOBAL_SHIFT               6
    4448
     49#define PAGE_NOT_CACHEABLE              (0 << PAGE_CACHEABLE_SHIFT)
    4550#define PAGE_CACHEABLE                  (1 << PAGE_CACHEABLE_SHIFT)
    46 #define PAGE_NOT_PRESENT                (1 << PAGE_NOT_PRESENT_SHIFT)
     51
     52#define PAGE_PRESENT                    (0 << PAGE_PRESENT_SHIFT)
     53#define PAGE_NOT_PRESENT                (1 << PAGE_PRESENT_SHIFT)
     54
    4755#define PAGE_USER                       (1 << PAGE_USER_SHIFT)
     56#define PAGE_KERNEL                     (0 << PAGE_USER_SHIFT)
     57
     58#define PAGE_READ                       (1 << PAGE_READ_SHIFT)
    4859#define PAGE_WRITE                      (1 << PAGE_WRITE_SHIFT)
    4960#define PAGE_EXEC                       (1 << PAGE_EXEC_SHIFT)
     61
    5062#define PAGE_GLOBAL                     (1 << PAGE_GLOBAL_SHIFT)
    5163

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

    r6be2c13 r973be387  
    4949        void (*mapping_remove)(as_t *, uintptr_t);
    5050        bool (*mapping_find)(as_t *, uintptr_t, bool, pte_t *);
    51         void (*mapping_update)(as_t *, uintptr_t, bool, const pte_t *);
     51        void (*mapping_update)(as_t *, uintptr_t, bool, pte_t *);
    5252        void (*mapping_make_global)(uintptr_t, size_t);
    5353} page_mapping_operations_t;

  • kernel/generic/src/console/cmd.c

    r6be2c13 r973be387  
    727727        else
    728728#endif
    729                 ptr = (uint8_t *) km_map(
    730                     argv[0].intval, sizeof(uint8_t), 0);
     729                ptr = (uint8_t *) km_map(argv[0].intval, sizeof(uint8_t),
     730                    PAGE_NOT_CACHEABLE);
    731731
    732732        const uint8_t val = pio_read_8(ptr);
    … …  
    757757        else
    758758#endif
    759                 ptr = (uint16_t *) km_map(
    760                     argv[0].intval, sizeof(uint16_t), 0);
     759                ptr = (uint16_t *) km_map(argv[0].intval, sizeof(uint16_t),
     760                    PAGE_NOT_CACHEABLE);
    761761
    762762        const uint16_t val = pio_read_16(ptr);
    … …  
    787787        else
    788788#endif
    789                 ptr = (uint32_t *) km_map(
    790                     argv[0].intval, sizeof(uint32_t), 0);
     789                ptr = (uint32_t *) km_map(argv[0].intval, sizeof(uint32_t),
     790                    PAGE_NOT_CACHEABLE);
    791791
    792792        const uint32_t val = pio_read_32(ptr);
    … …  
    818818#endif
    819819                ptr = (uint8_t *) km_map(argv[0].intval, sizeof(uint8_t),
    820                     PAGE_WRITE);
     820                    PAGE_NOT_CACHEABLE);
    821821
    822822        printf("write %" PRIxn ": %" PRIx8 "\n", argv[0].intval,
    … …  
    849849#endif
    850850                ptr = (uint16_t *) km_map(argv[0].intval, sizeof(uint16_t),
    851                     PAGE_WRITE);
     851                    PAGE_NOT_CACHEABLE);
    852852
    853853        printf("write %" PRIxn ": %" PRIx16 "\n", argv[0].intval,
    … …  
    880880#endif
    881881                ptr = (uint32_t *) km_map(argv[0].intval, sizeof(uint32_t),
    882                     PAGE_WRITE);
     882                    PAGE_NOT_CACHEABLE);
    883883
    884884        printf("write %" PRIxn ": %" PRIx32 "\n", argv[0].intval,

  • kernel/generic/src/ipc/irq.c

    r6be2c13 r973be387  
    9393#endif
    9494                ranges[i].base = km_map(pbase[i], ranges[i].size,
    95                     PAGE_WRITE);
     95                    PAGE_READ | PAGE_WRITE | PAGE_KERNEL | PAGE_NOT_CACHEABLE);
    9696                if (!ranges[i].base) {
    9797                        ranges_unmap(ranges, i);

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

    r6be2c13 r973be387  
    250250                uintptr_t page = km_map(init.tasks[i].paddr,
    251251                    init.tasks[i].size,
    252                     PAGE_WRITE | PAGE_CACHEABLE);
     252                    PAGE_READ | PAGE_WRITE | PAGE_CACHEABLE);
    253253                assert(page);
    254254

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

    r6be2c13 r973be387  
    12171217NO_TRACE static unsigned int area_flags_to_page_flags(unsigned int aflags)
    12181218{
    1219         unsigned int flags = PAGE_USER;
    1220 
    1221         // TODO: AS_AREA_READ currently has no effect.
    1222         // Readability is implied.
     1219        unsigned int flags = PAGE_USER | PAGE_PRESENT;
     1220
     1221        if (aflags & AS_AREA_READ)
     1222                flags |= PAGE_READ;
    12231223
    12241224        if (aflags & AS_AREA_WRITE)

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

    r6be2c13 r973be387  
    257257        if (frame) {
    258258                page = km_map(frame, PAGE_SIZE,
    259                     PAGE_WRITE | PAGE_CACHEABLE);
     259                    PAGE_READ | PAGE_WRITE | PAGE_CACHEABLE);
    260260                if (!page) {
    261261                        frame_free(frame, 1);

  • kernel/test/mm/mapping1.c

    r6be2c13 r973be387  
    4444
    4545        uintptr_t page0 = km_map(frame, FRAME_SIZE,
    46             PAGE_WRITE | PAGE_CACHEABLE);
     46            PAGE_READ | PAGE_WRITE | PAGE_CACHEABLE);
    4747        TPRINTF("Virtual address %p mapped to physical address %p.\n",
    4848            (void *) page0, (void *) frame);
    4949
    5050        uintptr_t page1 = km_map(frame, FRAME_SIZE,
    51             PAGE_WRITE | PAGE_CACHEABLE);
     51            PAGE_READ | PAGE_WRITE | PAGE_CACHEABLE);
    5252        TPRINTF("Virtual address %p mapped to physical address %p.\n",
    5353            (void *) page1, (void *) frame);
Note: See TracChangeset for help on using the changeset viewer.