bool tsh_exec() {
bool ret_value = false;
if (strcmp(&command_buffer, "kheap")==0) {
kheap_status();
return true;
} else if (strcmp(&command_buffer, "kheaptest")==0) {
kheap_test();
return true;
} else if (strcmp(&command_buffer, "ata")==0) {
ata_show_info();
return true;
} else if (strcmp(&command_buffer, "pci")==0) {
pci_show_info();
return true;
} else if (strcmp(&command_buffer, "atatest")==0) {
ata_rw_test(0);
return true;
} else if (strcmp(&command_buffer, "proc")==0) {
proc_info();
return true;
} else if (strcmp(&command_buffer, "kill")==0) {
proc_kill(1);
return true;
} else if (strcmp(&command_buffer, "reset")==0) {
kbrd_reset_system();
return true;
} else if (strcmp(&command_buffer, "help")==0) {
tiny_shell_help();
return true;
}
return ret_value;
}
void exception_hardware(uint32 nr, uint32 cr2)
{
if (nr == 14)
printf("page fault while accessing %x by %s (PID %d)\n", cr2, &proctab[current_task].name, current_task);
else
printf("%s (PID %d) raised an exception \"%s\"\n", &proctab[current_task].name, current_task, hardware_exceptions[nr]);
proc_kill(current_task);
}
int
kill(int pid, int sig)
{
switch(sig) {
case SIGNONE: return proc_exists(pid);
case SIGTERM: return proc_term(pid);
case SIGKILL: return proc_kill(pid);
default:
return -1;
break;
}
}
/*
* This gets called by _pt_fault_handler in mm/pagetable.c The
* calling function has already done a lot of error checking for
* us. In particular it has checked that we are not page faulting
* while in kernel mode. Make sure you understand why an
* unexpected page fault in kernel mode is bad in Weenix. You
* should probably read the _pt_fault_handler function to get a
* sense of what it is doing.
*
* Before you can do anything you need to find the vmarea that
* contains the address that was faulted on. Make sure to check
* the permissions on the area to see if the process has
* permission to do [cause]. If either of these checks does not
* pass kill the offending process, setting its exit status to
* EFAULT (normally we would send the SIGSEGV signal, however
* Weenix does not support signals).
*
* Now it is time to find the correct page (don't forget
* about shadow objects, especially copy-on-write magic!). Make
* sure that if the user writes to the page it will be handled
* correctly.
*
* Finally call pt_map to have the new mapping placed into the
* appropriate page table.
*
* @param vaddr the address that was accessed to cause the fault
*
* @param cause this is the type of operation on the memory
* address which caused the fault, possible values
* can be found in pagefault.h
*/
void
handle_pagefault(uintptr_t vaddr, uint32_t cause)
{
/*NOT_YET_IMPLEMENTED("VM: handle_pagefault");*/
vmmap_t *map = curproc->p_vmmap;
dbginfo(DBG_ERROR, proc_info, curproc);
dbginfo(DBG_ERROR, proc_list_info, NULL);
if(vaddr == NULL){
}
vmarea_t *vma = vmmap_lookup(map, ADDR_TO_PN(vaddr));
/*uintptr_t pagenum = PAGE_OFFSET(vaddr);*/
if(vma == NULL || !(cause & FAULT_USER)){
/*XXX permission checks*/
curproc->p_status = EFAULT;
proc_kill(curproc, EFAULT);
}
pframe_t *pf;
uintptr_t pagenum = ADDR_TO_PN(vaddr) - vma->vma_start+vma->vma_off;
/*XXX handle shadow objects*/
/*
int forWrite = 0;
if(cause & FAULT_WRITE){
forWrite = 1;
}
*/
/*
if(vma->vma_obj->mmo_shadowed != NULL){
shadow_lookuppage(vma->vma_obj->mmo_shadowed, pagenum, forWrite,&pf);
}else{
*/
pframe_get(vma->vma_obj, pagenum, &pf);
/*}*/
uintptr_t paddr = pt_virt_to_phys((uintptr_t)pf->pf_addr);
uintptr_t pdflags = PD_PRESENT | PD_WRITE | PD_USER;
uintptr_t ptflags = PT_PRESENT | PT_WRITE | PT_USER;
/*XXX tlb flush?*/
pt_map(curproc->p_pagedir,(uintptr_t)PAGE_ALIGN_DOWN(vaddr), paddr, pdflags, ptflags);
}
static void test_proc_kill(){
dbg(DBG_TEST, "testing proc_kill\n");
proc_t *test_proc = proc_create("proc_kill_test_proc");
kthread_t *test_thread = kthread_create(test_proc, sleep_function, NULL,
(void *) &test_proc->p_wait);
sched_make_runnable(test_thread);
yield();
proc_kill(test_proc, 7);
KASSERT(test_thread->kt_cancelled == 1);
KASSERT(test_thread->kt_retval == 0);
KASSERT(test_proc->p_status == 7);
int status;
do_waitpid(test_proc->p_pid, 0, &status);
dbg(DBG_TESTPASS, "all proc_kill tests passed!\n");
}
function dialog_say(int dialog)
{
if(dialogEntries[dialog].initialized == NULL) return;
proc_kill(4);
var soundID = -1;
if(dialogEntries[dialog].sound != NULL)
{
soundID = snd_play(dialogEntries[dialog].sound, 100, 0);
}
set(dialogText, SHOW);
(dialogText->pstring)[0] = dialogEntries[dialog].text;
dialogText->alpha = 0;
var timer = 32;
while(timer > 0 || snd_playing(soundID))
{
dialogText->pos_x = 0.5 * screen_size.x;
dialogText->pos_y = screen_size.y - 64;
if(timer > 8)
{
dialogText->alpha = minv(100, dialogText->alpha + 12 * time_step);
}
else
{
dialogText->alpha = maxv(0, dialogText->alpha - 12 * time_step);
}
if(!snd_playing(soundID))
timer -= time_step;
wait(1);
}
reset(dialogText, SHOW);
dialogText->alpha = 0;
}
/*
* This gets called by _pt_fault_handler in mm/pagetable.c The
* calling function has already done a lot of error checking for
* us. In particular it has checked that we are not page faulting
* while in kernel mode. Make sure you understand why an
* unexpected page fault in kernel mode is bad in Weenix. You
* should probably read the _pt_fault_handler function to get a
* sense of what it is doing.
*
* Before you can do anything you need to find the vmarea that
* contains the address that was faulted on. Make sure to check
* the permissions on the area to see if the process has
* permission to do [cause]. If either of these checks does not
* pass kill the offending process, setting its exit status to
* EFAULT (normally we would send the SIGSEGV signal, however
* Weenix does not support signals).
*
* Now it is time to find the correct page (don't forget
* about shadow objects, especially copy-on-write magic!). Make
* sure that if the user writes to the page it will be handled
* correctly.
*
* Finally call pt_map to have the new mapping placed into the
* appropriate page table.
*
* @param vaddr the address that was accessed to cause the fault
*
* @param cause this is the type of operation on the memory
* address which caused the fault, possible values
* can be found in pagefault.h
*/
void handle_pagefault(uintptr_t vaddr, uint32_t cause) {
/*NOT_YET_IMPLEMENTED("VM: handle_pagefault");*/
vmarea_t *vma;
pframe_t *pf;
int pflags = PD_PRESENT | PD_USER;
int writeflag = 0;
dbg(DBG_PRINT, "(GRADING3F)\n");
if ((vma = vmmap_lookup(curproc->p_vmmap, ADDR_TO_PN(vaddr))) == NULL) {
dbg(DBG_PRINT, "(GRADING3C 1)\n");
proc_kill(curproc, EFAULT);
return;
}
/*
if (vma->vma_prot & PROT_NONE) {
dbg(DBG_ERROR, "(GRADING3 3)\n");
proc_kill(curproc, EFAULT);
return;
}*/
if (!((cause & FAULT_WRITE) || (cause & FAULT_EXEC))
&& !(vma->vma_prot & PROT_READ)) {
dbg(DBG_PRINT, "(GRADING3D 3)\n");
proc_kill(curproc, EFAULT);
return;
}
if ((cause & FAULT_WRITE) && !(vma->vma_prot & PROT_WRITE)) {
dbg(DBG_PRINT, "(GRADING3D 3)\n");
proc_kill(curproc, EFAULT);
return;
}/*
if ((cause & FAULT_EXEC) && !(vma->vma_prot & PROT_EXEC)) {
dbg(DBG_ERROR, "(GRADING3 6)\n");
proc_kill(curproc, EFAULT);
return;;
}*/
if (cause & FAULT_WRITE) {
dbg(DBG_PRINT, "(GRADING3F)\n");
writeflag = 1;
}
if (pframe_lookup(vma->vma_obj,
ADDR_TO_PN(vaddr) - vma->vma_start + vma->vma_off, writeflag, &pf) < 0) {
dbg(DBG_PRINT, "(GRADING3D 4)\n");
proc_kill(curproc, EFAULT);
return;
}
if (cause & FAULT_WRITE) {
pframe_pin(pf);
dbg(DBG_PRINT, "(GRADING3F)\n");
pframe_dirty(pf);
/*
if ( < 0) {
dbg(DBG_ERROR, "(GRADING3 10)\n");
pframe_unpin(pf);
proc_kill(curproc, EFAULT);
return;
}*/
pframe_unpin(pf);
pflags |= PD_WRITE;
}
pt_map(curproc->p_pagedir, (uintptr_t) PAGE_ALIGN_DOWN(vaddr),
pt_virt_to_phys((uintptr_t) pf->pf_addr), pflags, pflags);
}
void
handle_pagefault(uintptr_t vaddr, uint32_t cause)
{
pframe_t *pf;
int ret_val;
vmarea_t *vma = vmmap_lookup(curproc->p_vmmap, ADDR_TO_PN(vaddr));
if(vma == NULL)
{
dbg(DBG_PRINT,"(GRADING3D 1): No vmarea found\n");
proc_kill(curproc,EFAULT);
return;
}
if(cause & FAULT_WRITE)
{
dbg(DBG_VM,"grade14\n");
dbg(DBG_PRINT,"(GRADING3D 1),checking permission for writing\n");
if(vma->vma_prot & PROT_WRITE)
{
dbg(DBG_VM,"grade15\n");
dbg(DBG_PRINT,"(GRADING3D 1),Vmarea has write permission\n");
ret_val = pframe_lookup(vma->vma_obj, ADDR_TO_PN(vaddr) - vma->vma_start + vma->vma_off, (cause & FAULT_WRITE),&pf);
if(ret_val<0)
{
dbg(DBG_VM,"grade16\n");
dbg(DBG_PRINT,"(GRADING3D 1),pframe could not be found\n");
proc_kill(curproc,EFAULT);
return;
}
pframe_dirty(pf);
KASSERT(pf);
dbg(DBG_PRINT,"(GRADING3A 5.a),pframe is not NULL\n");
KASSERT(pf->pf_addr);
dbg(DBG_PRINT,"(GRADING3A 5.a),pf->pf_addr is not NULL\n");
}
else
{
dbg(DBG_VM,"grade17\n");
dbg(DBG_PRINT,"(GRADING3D 1),Vmarea does not have write permission\n");
proc_kill(curproc,EFAULT);
return;
}
dbg(DBG_VM,"grade18\n");
dbg(DBG_PRINT,"(GRADING3D 1),Calling pt_map after write\n");
pt_map(curproc->p_pagedir,(uintptr_t)PAGE_ALIGN_DOWN(vaddr),pt_virt_to_phys((uintptr_t)pf->pf_addr),
(PD_WRITE|PD_PRESENT|PD_USER), (PT_WRITE|PT_PRESENT|PT_USER));
}
else
{
dbg(DBG_VM,"grade19\n");
dbg(DBG_PRINT,"(GRADING3D 1),checking permission for reading\n");
if(vma->vma_prot & PROT_READ)
{
dbg(DBG_VM,"grade20\n");
dbg(DBG_PRINT,"(GRADING3D 1),Vmarea has read permission\n");
ret_val = pframe_lookup(vma->vma_obj, ADDR_TO_PN(vaddr) - vma->vma_start + vma->vma_off, (cause & FAULT_WRITE),&pf);
if(ret_val<0)
{
dbg(DBG_VM,"grade21\n");
dbg(DBG_PRINT,"(GRADING3D 1),pframe could not be found\n");
proc_kill(curproc,EFAULT);
return;
}
dbg(DBG_VM,"grade22\n");
KASSERT(pf);
dbg(DBG_PRINT,"(GRADING3A 5.a),pframe is not NULL\n");
KASSERT(pf->pf_addr);
dbg(DBG_PRINT,"(GRADING3A 5.a),pf->pf_addr is not NULL\n");
}
else
{
dbg(DBG_VM,"grade23\n");
dbg(DBG_PRINT,"(GRADING3D 1),Vmarea does not have read permission\n");
proc_kill(curproc,EFAULT);
return;
}
dbg(DBG_VM,"grade24\n");
dbg(DBG_PRINT,"(GRADING3D 1),Calling pt_map after read\n");
pt_map(curproc->p_pagedir,(uintptr_t)PAGE_ALIGN_DOWN(vaddr),pt_virt_to_phys((uintptr_t)pf->pf_addr),
(PD_PRESENT|PD_USER), (PT_PRESENT|PT_USER));
}
}
void game_start()
{
#ifndef SKIP_INTRO
resetPpSwirl ();
level_load("menu2.wmb");
wait(3);
setHdr(LVL_INTRO_HDR_STRENGTH, LVL_INTRO_HDR_THRESHOLD, LVL_INTRO_HDR_EXPOSURE);
camera->arc = 60;
camera->ambient = 0;
fog_color = 0;
camera_path("path1");
PANEL* panBlack = pan_create(" ", 100);
vec_set(panBlack.blue, vector(8,8,8));
pan_setdigits(panBlack, 0, 5, 5, "Press [Space] to skip", font_create("Arial#24b"), 1, vDummy);
pan_setcolor(panBlack, 1, 1, vector(255,255,255));
set(panBlack, SHOW | LIGHT | OVERLAY);
var vMediaHandle = snd_play(g_musicIntro, 100, 0);
while (key_esc || key_space || key_enter)
wait(1);
while (snd_playing(vMediaHandle) && !key_esc && !key_space && !key_enter)
wait(1);
proc_kill((void*)camera_path);
ptr_remove(panBlack);
snd_stop(vMediaHandle);
vMediaHandle = 0;
#endif
nPlayerLifes = 3;
flying_man = 0;
gui_start();
// standard start level = temple
#ifndef SKIP_TO
lvlTempleInit();
#else
#ifdef SKIP_TO_LOTTIFANTLEVEL
lvlLfInit();
#endif
#ifdef SKIP_TO_BOSSLEVEL
lvlBossInit();
#endif
#ifdef SKIP_TO_LAVASTAGE
lvlLavastageInit();
#endif
#ifdef SKIP_TO_CREDITS
creditsInit();
#endif
#endif
}
/*
* This gets called by _pt_fault_handler in mm/pagetable.c The
* calling function has already done a lot of error checking for
* us. In particular it has checked that we are not page faulting
* while in kernel mode. Make sure you understand why an
* unexpected page fault in kernel mode is bad in Weenix. You
* should probably read the _pt_fault_handler function to get a
* sense of what it is doing.
*
* Before you can do anything you need to find the vmarea that
* contains the address that was faulted on. Make sure to check
* the permissions on the area to see if the process has
* permission to do [cause]. If either of these checks does not
* pass kill the offending process, setting its exit status to
* EFAULT (normally we would send the SIGSEGV signal, however
* Weenix does not support signals).
*
* Now it is time to find the correct page (don't forget
* about shadow objects, especially copy-on-write magic!). Make
* sure that if the user writes to the page it will be handled
* correctly.
*
* Finally call pt_map to have the new mapping placed into the
* appropriate page table.
*
* @param vaddr the address that was accessed to cause the fault
*
* @param cause this is the type of operation on the memory
* address which caused the fault, possible values
* can be found in pagefault.h
*/
void
handle_pagefault(uintptr_t vaddr, uint32_t cause)
{
/*NOT_YET_IMPLEMENTED("VM: handle_pagefault");*/
uint32_t res_vfn=ADDR_TO_PN(vaddr);
vmarea_t *temp_vmarea=vmmap_lookup(curproc->p_vmmap,res_vfn);
if(temp_vmarea==NULL)
{
proc_kill(curproc,EFAULT);
return;
}
if((cause&FAULT_PRESENT)&&(!(temp_vmarea->vma_prot&PROT_READ)))
{
proc_kill(curproc,EFAULT);
return;
}
if(cause&FAULT_RESERVED&&(!(temp_vmarea->vma_prot&PROT_NONE)))
{
proc_kill(curproc,EFAULT);
return;
}
if(cause&FAULT_EXEC&&(!(temp_vmarea->vma_prot&PROT_EXEC)))
{
proc_kill(curproc,EFAULT);
return;
}
if ((cause & FAULT_WRITE)&&!(temp_vmarea->vma_prot & PROT_WRITE))
{
do_exit(EFAULT);
return;
}
if((cause&FAULT_WRITE)==0)
{
if((temp_vmarea->vma_prot & PROT_READ)==0)
{
do_exit(EFAULT);
}
}
pframe_t *temp_pf_res=NULL;
uint32_t pagenum=temp_vmarea->vma_off+res_vfn-temp_vmarea->vma_start;
if(cause & FAULT_WRITE)/*******according to google group:1. pframe_get 2.pt_map(permission!!!)*************/
{
int tempres=pframe_lookup(temp_vmarea->vma_obj,pagenum,1, &temp_pf_res);
if(tempres<0)
{
proc_kill(curproc,EFAULT);
return;
}
uintptr_t paddr=pt_virt_to_phys((uintptr_t)temp_pf_res->pf_addr);
pt_map(curproc->p_pagedir,(uintptr_t)(PN_TO_ADDR(res_vfn)),paddr,PD_PRESENT|PD_WRITE|PD_USER,PT_PRESENT|PT_WRITE|PT_USER);
}
else{
int tempres=pframe_lookup(temp_vmarea->vma_obj,pagenum,0, &temp_pf_res);
if(tempres<0)
{
proc_kill(curproc,EFAULT);
return;
}
uintptr_t paddr=pt_virt_to_phys((uintptr_t)temp_pf_res->pf_addr);
pt_map(curproc->p_pagedir,(uintptr_t)(PN_TO_ADDR(res_vfn)),paddr,PD_PRESENT|PD_USER,PT_PRESENT|PT_USER);
}
}
