OpenXiangShan
/
nexus-am
mirror of https://github.com/OpenXiangShan/nexus-am.git
3
0
Fork 0
Code Issues Projects Releases Wiki Activity

rename regs to ctx

This commit is contained in:
Yanyan Jiang 2018-08-08 14:44:54 +00:00
parent 40c207a68d
commit 1e8eeff1c3
7 changed files with 62 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
am/am.h
View File

@ -77,7 +77,7 @@ _Device *_device(int n);
// ================== Asynchronous Extension (ASYE) ==================
int _asye_init(_Context *(*handler)(_Event ev, _Context *regs));
int _asye_init(_Context *(*handler)(_Event ev, _Context *ctx));
_Context *_kcontext(_Area kstack, void (*entry)(void *), void *arg);
void _yield();
int _intr_read();

40
am/arch/mips32-npc/src/asye.c
View File

@ -29,24 +29,24 @@ static void init_timer(int step) {
MTC0(CP0_COMPARE, compare, 0);
}
int _asye_init(_Context* (*l)(_Event ev, _Context *regs)){
int _asye_init(_Context* (*l)(_Event ev, _Context *ctx)){
H = l;
return 0;
}
_Context *_make(_Area kstack, void (*entry)(void *), void *args){
_Context *regs = (_Context *)kstack.start;
regs->sp = (uint32_t) kstack.end;
regs->epc = (uint32_t) entry;
_Context *ctx = (_Context *)kstack.start;
ctx->sp = (uint32_t) kstack.end;
ctx->epc = (uint32_t) entry;
static const char *envp[] = { "FUCKYOU=true", NULL };
uintptr_t *arg = args;
regs->a0 = 0;
regs->a1 = (uintptr_t)arg;
regs->a2 = (uintptr_t)envp;
for(; *arg; arg ++, regs->a0++);
return regs;
ctx->a0 = 0;
ctx->a1 = (uintptr_t)arg;
ctx->a2 = (uintptr_t)envp;
for(; *arg; arg ++, ctx->a0++);
return ctx;
}
void _yield(){
@ -67,13 +67,13 @@ void _intr_write(int enable) {
MTC0(CP0_STATUS, status, 0);
}
void irq_handle(struct _Context *regs){
cp0_cause_t *cause = (void*)&(regs->cause);
void irq_handle(struct _Context *ctx){
cp0_cause_t *cause = (void*)&(ctx->cause);
uint32_t exccode = cause->ExcCode;
uint32_t ipcode = cause->IP;
// print_timer();
// printk("[AM] cause:%x, status:%x, code:%x, ip:%x\n", regs->cause, regs->status, exccode, ipcode);
// printk("[AM] cause:%x, status:%x, code:%x, ip:%x\n", ctx->cause, ctx->status, exccode, ipcode);
_Event ev;
ev.event = _EVENT_NULL;
@ -85,7 +85,7 @@ void irq_handle(struct _Context *regs){
if(ipcode & IP_TIMER_MASK) {
ev.event = _EVENT_IRQ_TIMER;
cause->IP = 0;
asm volatile("mtc0 %0, $13, 0;nop;nop"::"r"(regs->cause));
asm volatile("mtc0 %0, $13, 0;nop;nop"::"r"(ctx->cause));
} else {
printk("invalid ipcode = %x\n", ipcode);
_halt(-1);
@ -93,8 +93,8 @@ void irq_handle(struct _Context *regs){
break;
}
case EXC_SYSCALL:
regs->epc += 4;
if(regs->a0 == -1)
ctx->epc += 4;
if(ctx->a0 == -1)
ev.event = _EVENT_YIELD;
else
ev.event = _EVENT_SYSCALL;
@ -108,15 +108,15 @@ void irq_handle(struct _Context *regs){
case EXC_RI:
case EXC_OV:
default:
printk("unhandled exccode = %x, epc:%08x, badvaddr:%08x\n", exccode, regs->epc, regs->badvaddr);
printk("cp0: base:%08x, cause:%08x, status:%08x\n", regs->base, regs->cause, regs->status);
printk("unhandled exccode = %x, epc:%08x, badvaddr:%08x\n", exccode, ctx->epc, ctx->badvaddr);
printk("cp0: base:%08x, cause:%08x, status:%08x\n", ctx->base, ctx->cause, ctx->status);
_halt(-1);
}
// printf("regs: t0:%x, t1:%x, t2:%x, t3:%x\n", regs->t0, regs->t1, regs->t2, regs->t3);
_Context *ret = regs;
// printf("ctx: t0:%x, t1:%x, t2:%x, t3:%x\n", ctx->t0, ctx->t1, ctx->t2, ctx->t3);
_Context *ret = ctx;
if(H) {
_Context *next = H(ev, regs);
_Context *next = H(ev, ctx);
if(next != NULL) ret = next;
}
/*

40
am/arch/x86-qemu/src/asye.c
View File

@ -25,7 +25,7 @@ void vecsys();
void irqall();
void irq_handle(struct TrapFrame *tf) {
_Context regs = {
_Context ctx = {
.eax = tf->eax, .ebx = tf->ebx, .ecx = tf->ecx, .edx = tf->edx,
.esi = tf->esi, .edi = tf->edi, .ebp = tf->ebp, .esp3 = 0,
.eip = tf->eip, .eflags = tf->eflags,
@ -34,13 +34,13 @@ void irq_handle(struct TrapFrame *tf) {
};
if (tf->cs & DPL_USER) { // interrupt at user code
regs.ss = tf->ss;
regs.esp3 = tf->esp;
regs.ss0 = KSEL(SEG_KDATA);
regs.esp0 = (uint32_t)tf + 68;
ctx.ss = tf->ss;
ctx.esp3 = tf->esp;
ctx.ss0 = KSEL(SEG_KDATA);
ctx.esp0 = (uint32_t)tf + 68;
} else { // interrupt at kernel code
regs.ss0 = KSEL(SEG_KDATA);
regs.esp0 = (uint32_t)tf + 60; // the %esp before interrupt
ctx.ss0 = KSEL(SEG_KDATA);
ctx.esp0 = (uint32_t)tf + 60; // the %esp before interrupt
}
if (tf->irq >= 32 && tf->irq < 64) {
@ -75,9 +75,9 @@ void irq_handle(struct TrapFrame *tf) {
ev.ref = get_cr2();
} else if (tf->irq < 32) ev.event = _EVENT_ERROR;
_Context *ret = &regs;
_Context *ret = &ctx;
if (H) {
_Context *next = H(ev, &regs);
_Context *next = H(ev, &ctx);
if (next != NULL) {
ret = next;
}
@ -207,21 +207,21 @@ int _asye_init(_Context*(*handler)(_Event, _Context*)) {
}
_Context *_kcontext(_Area stack, void (*entry)(void *), void *arg) {
_Context *regs = (_Context *)stack.start;
regs->eax = regs->ebx = regs->ecx = regs->edx = 0;
regs->esi = regs->edi = regs->ebp = regs->esp3 = 0;
_Context *ctx = (_Context *)stack.start;
ctx->eax = ctx->ebx = ctx->ecx = ctx->edx = 0;
ctx->esi = ctx->edi = ctx->ebp = ctx->esp3 = 0;
regs->ss0 = 0; // only used for ring3 procs
regs->esp0 = (uint32_t)stack.end;
regs->cs = KSEL(SEG_KCODE);
regs->ds = regs->es = regs->ss = KSEL(SEG_KDATA);
regs->eip = (uint32_t)entry;
regs->eflags = FL_IF;
ctx->ss0 = 0; // only used for ring3 procs
ctx->esp0 = (uint32_t)stack.end;
ctx->cs = KSEL(SEG_KCODE);
ctx->ds = ctx->es = ctx->ss = KSEL(SEG_KDATA);
ctx->eip = (uint32_t)entry;
ctx->eflags = FL_IF;
uint32_t **esp = (uint32_t **)&regs->esp0;
uint32_t **esp = (uint32_t **)&ctx->esp0;
*(*esp -= 1) = (uint32_t)arg; // argument
*(*esp -= 1) = 0; // return address
return regs;
return ctx;
}
void _yield() {

20
am/arch/x86-qemu/src/pte.c
View File

@ -108,14 +108,14 @@ int _map(_Protect *p, void *va, void *pa, int prot) {
}
_Context *_ucontext(_Protect *p, _Area ustack, _Area kstack, void *entry, void *args) {
_Context *regs = (_Context*)kstack.start;
regs->cs = USEL(SEG_UCODE);
regs->ds = regs->es = regs->ss = USEL(SEG_UDATA);
regs->esp3 = (uint32_t)ustack.end;
regs->ss0 = KSEL(SEG_KDATA);
regs->esp0 = (uint32_t)kstack.end;
regs->eip = (uint32_t)entry;
regs->eflags = FL_IF;
regs->eax = (uint32_t)args;
return regs;
_Context *ctx = (_Context*)kstack.start;
ctx->cs = USEL(SEG_UCODE);
ctx->ds = ctx->es = ctx->ss = USEL(SEG_UDATA);
ctx->esp3 = (uint32_t)ustack.end;
ctx->ss0 = KSEL(SEG_KDATA);
ctx->esp0 = (uint32_t)kstack.end;
ctx->eip = (uint32_t)entry;
ctx->eflags = FL_IF;
ctx->eax = (uint32_t)args;
return ctx;
}

4
tests/asyetest/main.c
View File

@ -3,7 +3,7 @@
#include <klib.h>
int ntraps = 0;
_Context* handler(_Event ev, _Context *regs) {
_Context* handler(_Event ev, _Context *ctx) {
switch (ev.event) {
case _EVENT_IRQ_TIMER:
printf(".");
@ -25,7 +25,7 @@ _Context* handler(_Event ev, _Context *regs) {
ntraps++;
break;
}
return regs;
return ctx;
}
int main(){

2
tests/segmenttest/main.c
View File

@ -5,7 +5,7 @@
_Context testcase_regs;
int ntraps = 0;
_Context* handler(_Event ev, _Context *regs) {
_Context* handler(_Event ev, _Context *ctx) {
switch (ev.event) {
case _EVENT_IRQ_TIMER:
printf(".");

16
tests/vmtest/main.c
View File

@ -2,10 +2,10 @@
#include <amdev.h>
#include <klib.h>
_Context *ctx;
_Context *uctx;
int ntraps = 0;
_Context* handler(_Event ev, _Context *regs) {
_Context* handler(_Event ev, _Context *ctx) {
switch (ev.event) {
case _EVENT_YIELD:
break;
@ -21,17 +21,17 @@ _Context* handler(_Event ev, _Context *regs) {
(ev.cause & _PROT_WRITE) ? "[write fail]" : "");
break;
case _EVENT_SYSCALL:
printf("%d ", regs->GPR1);
printf("%d ", ctx->GPR1);
break;
default:
assert(0);
}
if (ctx) {
regs = ctx;
ctx = NULL;
if (uctx) {
ctx = uctx;
uctx = NULL;
}
return regs;
return ctx;
}
static uintptr_t st;
@ -85,7 +85,7 @@ int main() {
_Area k = { .start = kstk, .end = kstk + 4096 };
_Area u = { .start = ptr + pgsz, .end = ptr + pgsz * 2 };
ctx = _ucontext(&prot, u, k, ptr, NULL);
uctx = _ucontext(&prot, u, k, ptr, NULL);
_switch(&prot);
_intr_write(1);