| 0,0 → 1,213 |
|---|
| /* |
| * Copyright (c) 2007 Pavel Jancik, Michal Kebrt |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * - Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * - The name of the author may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| /** @addtogroup arm32mm |
| * @{ |
| */ |
| /** @file |
| * @brief Page fault related functions. |
| */ |
| #include <panic.h> |
| #include <arch/exception.h> |
| #include <arch/debug/print.h> |
| #include <arch/mm/page_fault.h> |
| #include <mm/as.h> |
| #include <genarch/mm/page_pt.h> |
| #include <arch.h> |
| #include <interrupt.h> |
| |
| /** Returns value stored in fault status register. |
| * |
| * @return Value stored in CP15 fault status register (FSR). |
| */ |
| static inline fault_status_t read_fault_status_register(void) |
| { |
| fault_status_union_t fsu; |
| |
| /* fault status is stored in CP15 register 5 */ |
| asm volatile ( |
| "mrc p15, 0, %0, c5, c0, 0" |
| : "=r"(fsu.dummy) |
| ); |
| return fsu.fs; |
| } |
| |
| /** Returns FAR (fault address register) content. |
| * |
| * @return FAR (fault address register) content (address that caused a page |
| * fault) |
| */ |
| static inline uintptr_t read_fault_address_register(void) |
| { |
| uintptr_t ret; |
| |
| /* fault adress is stored in CP15 register 6 */ |
| asm volatile ( |
| "mrc p15, 0, %0, c6, c0, 0" |
| : "=r"(ret) |
| ); |
| return ret; |
| } |
| |
| /** Decides whether the instruction is load/store or not. |
| * |
| * @param instr Instruction |
| * |
| * @return true when instruction is load/store, false otherwise |
| */ |
| static inline bool is_load_store_instruction(instruction_t instr) |
| { |
| /* load store immediate offset */ |
| if (instr.type == 0x2) { |
| return true; |
| } |
| |
| /* load store register offset */ |
| if (instr.type == 0x3 && instr.bit4 == 0) { |
| return true; |
| } |
| |
| /* load store multiple */ |
| if (instr.type == 0x4) { |
| return true; |
| } |
| |
| /* oprocessor load/store */ |
| if (instr.type == 0x6) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** Decides whether the instruction is swap or not. |
| * |
| * @param instr Instruction |
| * |
| * @return true when instruction is swap, false otherwise |
| */ |
| static inline bool is_swap_instruction(instruction_t instr) |
| { |
| /* swap, swapb instruction */ |
| if (instr.type == 0x0 && |
| (instr.opcode == 0x8 || instr.opcode == 0xa) && |
| instr.access == 0x0 && instr.bits567 == 0x4 && instr.bit4 == 1) { |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** Decides whether read or write into memory is requested. |
| * |
| * @param instr_addr Address of instruction which tries to access memory. |
| * @param badvaddr Virtual address the instruction tries to access. |
| * |
| * @return Type of access into memory, PF_ACCESS_EXEC if no memory access is |
| * requested. |
| */ |
| static pf_access_t get_memory_access_type(uint32_t instr_addr, |
| uintptr_t badvaddr) |
| { |
| instruction_union_t instr_union; |
| instr_union.pc = instr_addr; |
| |
| instruction_t instr = *(instr_union.instr); |
| |
| /* undefined instructions */ |
| if (instr.condition == 0xf) { |
| panic("page_fault - instruction doesn't access memory " |
| "(instr_code: %x, badvaddr:%x)", instr, badvaddr); |
| return PF_ACCESS_EXEC; |
| } |
| |
| /* load store instructions */ |
| if (is_load_store_instruction(instr)) { |
| if (instr.access == 1) { |
| return PF_ACCESS_READ; |
| } else { |
| return PF_ACCESS_WRITE; |
| } |
| } |
| |
| /* swap, swpb instruction */ |
| if (is_swap_instruction(instr)) { |
| return PF_ACCESS_WRITE; |
| } |
| |
| panic("page_fault - instruction doesn't access memory " |
| "(instr_code: %x, badvaddr:%x)", instr, badvaddr); |
| |
| return PF_ACCESS_EXEC; |
| } |
| |
| /** Handles "data abort" exception (load or store at invalid address). |
| * |
| * @param exc_no Exception number. |
| * @param istate CPU state when exception occured. |
| */ |
| void data_abort(int exc_no, istate_t *istate) |
| { |
| fault_status_t fsr __attribute__ ((unused)) = |
| read_fault_status_register(); |
| uintptr_t badvaddr = read_fault_address_register(); |
| |
| pf_access_t access = get_memory_access_type(istate->pc, badvaddr); |
| |
| int ret = as_page_fault(badvaddr, access, istate); |
| |
| if (ret == AS_PF_FAULT) { |
| print_istate(istate); |
| dprintf("page fault - pc: %x, va: %x, status: %x(%x), " |
| "access:%d\n", istate->pc, badvaddr, fsr.status, fsr, |
| access); |
| |
| fault_if_from_uspace(istate, "Page fault: %#x", badvaddr); |
| panic("page fault\n"); |
| } |
| } |
| |
| /** Handles "prefetch abort" exception (instruction couldn't be executed). |
| * |
| * @param exc_no Exception number. |
| * @param istate CPU state when exception occured. |
| */ |
| void prefetch_abort(int exc_no, istate_t *istate) |
| { |
| int ret = as_page_fault(istate->pc, PF_ACCESS_EXEC, istate); |
| |
| if (ret == AS_PF_FAULT) { |
| dprintf("prefetch_abort\n"); |
| print_istate(istate); |
| panic("page fault - prefetch_abort at address: %x\n", |
| istate->pc); |
| } |
| } |
| |
| /** @} |
| */ |