Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 2297 → Rev 2298

/branches/arm/kernel/arch/arm32/include/exception.h
38,6 → 38,7
#define KERN_arm32_EXCEPTION_H_
 
#include <arch/types.h>
#include <arch/regutils.h>
 
#define HIGH_EXCEPTION_VECTORS
 
91,18 → 92,17
 
static inline void istate_set_retaddr(istate_t *istate, uintptr_t retaddr)
{
istate->lr = retaddr;
istate->pc = retaddr;
}
 
/** Return true if exception happened while in userspace */
static inline int istate_from_uspace(istate_t *istate)
{
return !(istate->lr & 0x80000000);
return 0;
return (istate->spsr & STATUS_REG_MODE_MASK) == USER_MODE;
}
static inline unative_t istate_get_pc(istate_t *istate)
{
return istate->lr;
return istate->pc;
}
 
extern void setup_exception_stacks(void);
/branches/arm/kernel/arch/arm32/src/exception.c
65,6 → 65,7
@prev mode was usermode \n\
ldmfd r13!, {r0} \n\
ldr r13, =supervisor_sp \n\
ldr r13, [r13] \n\
stmfd r13!, {lr} \n\
stmfd r13!, {r0-r12} \n\
stmfd r13!, {r13, lr}^ \n\
87,8 → 88,9
mov r2, lr \n\
stmfd r13!, {r4-r12} \n\
mov r1, r13 \n\
@following two lines are for debugging \n\
mov sp, #0 \n\
mov lr, #0 \n\
mov sp, #0 \n\
msr cpsr_c, r0 \n\
\n\
ldmfd r13!, {r4, r5, r6, r7} \n\
130,9 → 132,7
msr cpsr_c, r0 \n\
\n\
@actual return \n\
\n\
ldmfd r13, {r0-r12, pc}^ \n\
4:"
4: ldmfd r13, {r0-r12, pc}^"
);
}
 
246,6 → 246,9
*/
static void swi_exception(int exc_no, istate_t* istate)
{
dprintf("SYSCALL: r0-r4: %x, %x, %x, %x, %x; pc: %x", istate->r0,
istate->r1, istate->r2, istate->r3, istate->r4, istate->pc);
 
istate->r0 = syscall_handler(
istate->r0,
istate->r1,
/branches/arm/kernel/arch/arm32/src/arm32.c
152,7 → 152,7
/** Perform arm32 specific tasks needed before the new thread is scheduled. */
void before_thread_runs_arch(void)
{
supervisor_sp = (uintptr_t) &THREAD->kstack/*[THREAD_STACK_SIZE-SP_DELTA]*/;
supervisor_sp = (uintptr_t) &THREAD->kstack[THREAD_STACK_SIZE-SP_DELTA];
}
 
void after_thread_ran_arch(void)
194,47 → 194,59
*/
void userspace(uspace_arg_t *kernel_uarg)
{
// dprintf("userspace\n");
// WILL be changed .. after exception return .. eret will be done
/*
volatile ustate_t ustate;
dprintf("userspace\n");
 
dprintf("userspce krnl_uard .uspace_uarg(%X), .uspace_entry(%X), .uspace_stack(%X)\n",
(unsigned int)(kernel_uarg->uspace_uarg),
kernel_uarg->uspace_entry,
kernel_uarg->uspace_stack);
// Step 1 ... prepare user space environmen
// set first paramater
 
volatile ustate_t ustate;
 
//Step 1 ... prepare user space environment
//set first paramater
ustate.r0 = (uintptr_t) kernel_uarg->uspace_uarg;
// clear other registers
 
//clear other registers
ustate.r1 = ustate.r2 = ustate.r3 = ustate.r4 =
ustate.r5 = ustate.r6 = ustate.r7 = ustate.r8 =
ustate.r9 = ustate.r10 = ustate.r11 = ustate.r12 = 1;
ustate.lr = 3;
// set user stack
 
//set user stack
ustate.sp = ((uint32_t)kernel_uarg->uspace_stack)+PAGE_SIZE;
// set where uspace executin starts
 
//set where uspace executin starts
ustate.pc = (uintptr_t) kernel_uarg->uspace_entry;
 
// status register in user mode
 
//status register in user mode
ipl_t cpsr = current_status_reg_read();
cpsr &= ~STATUS_REG_MODE_MASK | USER_MODE;
//
ipl_t tmpsr = (cpsr & ~STATUS_REG_MODE_MASK) | ABORT_MODE;
ipl_t tmpsr = (cpsr & ~STATUS_REG_MODE_MASK) | SUPERVISOR_MODE;
 
asm __volatile__ (
"mov r0, %0 \n" // save pointer into ustate struct
"mov r1, %1 \n" // save cspr
"msr cpsr_c, %2 \n" // change mode into any exception mode
"msr spsr_c, r1 \n" // set saved cpsr ... as user mode
"ldmfd r0, {r0-r12, sp, lr, pc}^\n" // jump into user mode
// save pointer into ustate struct
"mov r0, %0 \n"
// save cspr
"mov r1, %1 \n"
// change mode into any exception mode
"msr cpsr_c, %2 \n"
// set saved cpsr
"msr spsr_c, r1 \n"
 
"mov sp, r0 \n"
// replace almost all registers
"ldmfd sp!, {r0-r12, sp, lr}^\n"
//jump to the usermode
"ldmfd sp!, {pc}^"
: // no output
: "r"(&ustate), "r"(cpsr), "r"(tmpsr) //
: "r0","r1"
);
*/
while(1)
;
 
while(1) ;
}
/** @}
*/
/branches/arm/kernel/arch/arm32/src/mm/page_fault.c
44,11 → 44,13
//TODO: remove in final version
static void print_istate(istate_t* istate);
static void print_istate(istate_t* istate) {
dprintf("\nIstate dump:\n");
dprintf(" r0:%X r1:%X r2:%X r3:%X\n", istate->r0, istate->r1, istate->r2, istate->r3);
dprintf(" r4:%X r5:%X r6:%X r7:%X\n", istate->r4, istate->r5, istate->r6, istate->r7);
dprintf(" r8:%X r8:%X r10:%X r11:%X\n", istate->r8, istate->r9, istate->r10, istate->r11);
dprintf(" r12:%X sp:%X lr:%X spsr:%X\n", istate->r12, istate->sp, istate->lr, istate->spsr);
dprintf("\nIstate dump:\n");
dprintf(" r0:%X r1:%X r2:%X r3:%X\n", istate->r0, istate->r1, istate->r2, istate->r3);
dprintf(" r4:%X r5:%X r6:%X r7:%X\n", istate->r4, istate->r5, istate->r6, istate->r7);
dprintf(" r8:%X r8:%X r10:%X r11:%X\n", istate->r8, istate->r9, istate->r10, istate->r11);
dprintf(" r12:%X sp:%X lr:%X spsr:%X\n", istate->r12, istate->sp, istate->lr, istate->spsr);
dprintf(" pc:%X\n", istate->pc);
}
 
/**
208,10 → 210,10
fault_status_t fsr = read_fault_status_register();
uintptr_t page = read_fault_address_register();
 
pf_access_t access = get_memmory_access_type( istate->lr, page);
pf_access_t access = get_memmory_access_type( istate->pc, page);
 
// print_istate(istate);
dprintf(" page fault : ip:%X, va:%X, status:%x(%x), access:%d\n", istate->lr, page, fsr.status,fsr, access);
dprintf(" page fault : ip:%X, va:%X, status:%x(%x), access:%d\n", istate->pc, page, fsr.status,fsr, access);
 
/* Alf: Will be commented until stack problem will be solved ...
as_page_fault make consequent page faults*/
220,12 → 222,11
dprintf(" as_page_fault ret:%d\n", ret);
if (ret == AS_PF_FAULT) {
fault_if_from_uspace(istate, "Page fault: %#x", page);
 
panic("page fault\n");
panic("page fault\n");
}
 
// TODO: Remove this ... now for testing purposes ... it's bad to test page faults in kernel, where no page faults should occures
panic("page fault ... solved\n");
// panic("page fault ... solved\n");
 
}
 
236,21 → 237,20
* \param n number of exception
*/
void prefetch_abort(int n, istate_t *istate) {
// Prefetch can be made be bkpt instruction
print_istate(istate);
dprintf(" prefetch_abourt ... instruction on adress:%x can't be fetched\n", istate->lr);
dprintf(" prefetch_abourt ... instruction on adress:%x can't be fetched\n", istate->pc);
 
/* Alf: Will be commented until stack problem will be solved ...
as_page_fault make consequent page faults*/
 
int ret = as_page_fault(istate->lr, PF_ACCESS_EXEC, istate);
int ret = as_page_fault(istate->pc, PF_ACCESS_EXEC, istate);
dprintf(" as_page_fault ret:%d\n", ret);
if (ret == AS_PF_FAULT) {
panic("page fault - instruction fetch at addr:%X\n", istate->lr);
panic("page fault - instruction fetch at addr:%X\n", istate->pc);
}
 
 
panic("Prefetch abourt ... solved");
// panic("Prefetch abourt ... solved");
}
 
/** @}