// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
/*stone's solution for lab3-B*/
int32_t ret = -E_INVAL;
switch (syscallno){
case SYS_cputs:
sys_cputs((char*)a1, a2);
ret = 0;
break;
case SYS_cgetc:
ret = sys_cgetc();
break;
case SYS_getenvid:
ret = sys_getenvid();
break;
case SYS_env_destroy:
ret = sys_env_destroy(a1);
break;
case SYS_map_kernel_page:
ret = sys_map_kernel_page((void*)a1, (void*)a2);
break;
case SYS_sbrk:
ret = sys_sbrk(a1);
break;
default:
break;
}
return ret;
//panic("syscall not implemented");
}
// Dispatches to the correct kernel function, passing the arguments.
int64_t
syscall(uint64_t syscallno, uint64_t a1, uint64_t a2, uint64_t a3, uint64_t a4, uint64_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
//panic("syscall not implemented");
int ret_val = 0;
switch (syscallno) {
case SYS_cputs:
sys_cputs((char *)a1, a2);
break;
case SYS_cgetc:
ret_val = sys_cgetc();
break;
case SYS_getenvid:
ret_val = sys_getenvid();
break;
case SYS_env_destroy:
ret_val = sys_env_destroy(a1);
break;
default:
ret_val = -E_INVAL;
break;
}
return ret_val;
}
// Dispatches to the correct kernel function, passing the arguments.
int64_t
syscall(uint64_t syscallno, uint64_t a1, uint64_t a2, uint64_t a3, uint64_t a4, uint64_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
// panic("syscall not implemented");
switch (syscallno) {
case SYS_cputs:
sys_cputs((const char *)a1, (size_t)a2);
return 0;
case SYS_cgetc:
return sys_cgetc();
case SYS_getenvid:
return sys_getenvid();
case SYS_env_destroy:
return sys_env_destroy(a1);
case SYS_yield:
sys_yield();
return 0;
case SYS_page_alloc:
return sys_page_alloc((envid_t)a1, (void *)a2,(int)a3);
case SYS_page_map:
return sys_page_map((envid_t)a1, (void *)a2, (envid_t)a3, (void *)a4, (int)a5);
case SYS_page_unmap:
return sys_page_unmap((envid_t)a1, (void *)a2);
case SYS_exofork:
return sys_exofork();
case SYS_env_set_status:
return sys_env_set_status((envid_t)a1, a2);
case SYS_env_set_pgfault_upcall:
return sys_env_set_pgfault_upcall((envid_t)a1,(void *)a2);
case SYS_ipc_try_send:
return sys_ipc_try_send((envid_t)a1, (uint32_t)a2, (void *)a3, a4);
case SYS_ipc_recv:
return sys_ipc_recv((void *)a1);
case SYS_env_set_trapframe:
return sys_env_set_trapframe((envid_t)a1, (struct Trapframe *)a2);
case SYS_time_msec:
return sys_time_msec();
case SYS_packet_transmit:
return sys_packet_transmit((char*)a1,(size_t)a2);
case SYS_packet_receive:
return sys_packet_receive((char *)a1);
//lab 7 code from here
case SYS_insmod:
return sys_insmod((char *)a1, (char *)a2,(char *)a3);
case SYS_rmmod:
return sys_rmmod((char *)a1);
case SYS_lsmod:
return sys_lsmod();
case SYS_depmod:
return sys_depmod((char *)a1);
//lab7 code ends here
default:
return -E_NO_SYS;
}
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
//
// TBD: gain 10+ percent of performance improvement
// by using goto-label-array.
switch(syscallno) {
case SYS_cputs:
sys_cputs((char *) a1, (size_t) a2);
break;
case SYS_cgetc:
return sys_cgetc();
case SYS_getenvid:
return sys_getenvid();
case SYS_env_destroy:
sys_env_destroy(a1);
break;
case SYS_exofork:
return sys_exofork();
case SYS_env_set_status:
return sys_env_set_status(a1, a2);
default:
cprintf("Error syscall(%u)\n", syscallno);
panic("syscall not implemented");
return -E_INVAL;
}
return 0;
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
curenv->env_syscalls++;
switch(syscallno){
case SYS_cputs:
sys_cputs((char *)a1, (size_t)a2);break;
case SYS_cgetc:
sys_cgetc();break;
case SYS_getenvid:
return sys_getenvid();
case SYS_env_destroy:
return sys_env_destroy((envid_t)a1);
case SYS_dump_env:
sys_dump_env();break;
case SYS_page_alloc:
return sys_page_alloc((envid_t)a1, (void *)a2, (int)a3);
case SYS_page_map: {
return sys_page_map((envid_t)a1, (void *)a2,
(envid_t)a3, (void *)a4, (int)a5);
}
case SYS_page_unmap:
return sys_page_unmap((envid_t)a1, (void *)a2);
case SYS_exofork:
return sys_exofork();
case SYS_env_set_status:
return sys_env_set_status((envid_t)a1,(int)a2);
case SYS_env_set_trapframe:
return sys_env_set_trapframe((envid_t)a1,
(struct Trapframe *)a2);
case SYS_env_set_pgfault_upcall:
return sys_env_set_pgfault_upcall((envid_t)a1, (void *)a2);
case SYS_yield:
sys_yield();break;//new add syscall for lab4;
case SYS_ipc_try_send:
return sys_ipc_try_send((envid_t)a1, (uint32_t)a2,
(void *)a3, (unsigned)a4);
case SYS_ipc_recv:
return sys_ipc_recv((void *)a1);
case SYS_ide_read:
sys_ide_read((uint32_t)a1, (void *)a2, (size_t)a3);
break;
case SYS_ide_write:
sys_ide_write((uint32_t)a1, (void *)a2, (size_t)a3);
break;
case SYS_time_msec:
return sys_time_msec();
case NSYSCALLS:
break;
default:
return -E_INVAL;
}
return 0;
//panic("syscall not implemented");
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
int32_t ret = -E_INVAL;
switch(syscallno) {
case SYS_cputs:
sys_cputs((char *)a1, a2);
break;
case SYS_cgetc:
ret = sys_cgetc();
break;
case SYS_getenvid:
ret = sys_getenvid();
break;
case SYS_env_destroy:
ret = sys_env_destroy(a1);
break;
case SYS_yield:
sys_yield();
ret = 0;
break;
case SYS_map_kernel_page:
ret = sys_map_kernel_page((void *)a1, (void *)a2);
break;
case SYS_sbrk:
ret = sys_sbrk(a1);
break;
case SYS_exofork:
ret = sys_exofork();
break;
case SYS_env_set_status:
ret = sys_env_set_status(a1,a2);
break;
case SYS_page_alloc:
ret = sys_page_alloc(a1,(void*)a2,a3);
break;
case SYS_page_map:
ret = sys_page_map(a1,(void*)a2,a3,(void*)a4,a5);
break;
case SYS_page_unmap:
ret = sys_page_unmap(a1,(void*)a2);
break;
case SYS_env_set_pgfault_upcall:
ret = sys_env_set_pgfault_upcall(a1,(void*)a2);
break;
case SYS_ipc_try_send:
ret = sys_ipc_try_send(a1,a2,(void*)a3,a4);
break;
case SYS_ipc_recv:
ret = sys_ipc_recv((void*)a1);
}
return ret;
// panic("syscall not implemented");
}
int
getchar(void)
{
int r;
// sys_cgetc does not block, but getchar should.
while ((r = sys_cgetc()) == 0){}
//sleep(1);
return r;
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
/* lj */
int ret = 0;
switch(syscallno) {
case SYS_cputs:
sys_cputs((const char *)a1, a2);
break;
case SYS_cgetc:
ret = sys_cgetc();
break;
case SYS_getenvid:
ret = sys_getenvid();
break;
case SYS_env_destroy:
ret = sys_env_destroy(a1);
break;
case SYS_yield:
sys_yield();
break;
case SYS_exofork:
ret = sys_exofork();
break;
case SYS_env_set_status:
ret = sys_env_set_status((envid_t)a1, a2);
break;
case SYS_page_alloc:
ret = sys_page_alloc((envid_t)a1, (void *)a2, a3);
break;
case SYS_page_map:
ret = sys_page_map((envid_t)a1, (void *)a2, (envid_t)a3, (void *)a4, a5);
break;
case SYS_page_unmap:
ret = sys_page_unmap((envid_t)a1, (void *)a2);
break;
case SYS_env_set_pgfault_upcall:
ret = sys_env_set_pgfault_upcall((envid_t)a1, (void *)a2);
break;
case SYS_ipc_try_send:
ret = sys_ipc_try_send((envid_t)a1, a2, (void *)a3, a4);
break;
case SYS_ipc_recv:
ret = sys_ipc_recv((void *)a1);
break;
default:
ret = -E_INVAL;
break;
}
//panic("syscall not implemented");
//cprintf("%d return to user %d\n", syscallno, ret);
return ret;
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
int32_t r =0;
switch(syscallno){
case SYS_cputs:
sys_cputs((const char*)a1,(size_t)a2);
break;
case SYS_cgetc:
r = sys_cgetc();
break;
case SYS_getenvid:
r = sys_getenvid();
break;
case SYS_env_destroy:
r = sys_env_destroy((envid_t)a1);
break;
case SYS_yield:
sys_yield();
r =0;
break;
case SYS_exofork:
r = sys_exofork();
break;
case SYS_env_set_status:
r = sys_env_set_status((envid_t)a1,(int)a2);
break;
case SYS_page_alloc:
r = sys_page_alloc((envid_t)a1 ,(void *)a2, (int)a3);
break;
case SYS_page_map:
r = sys_page_map((envid_t)a1, (void *)a2, (envid_t)a3, (void *)a4, (int)a5);
break;
case SYS_page_unmap:
r = sys_page_unmap((envid_t)a1,(void *)a2);
break;
case SYS_env_set_pgfault_upcall:
r = sys_env_set_pgfault_upcall((envid_t)a1, (void *)a2);
break;
case SYS_ipc_try_send:
r = sys_ipc_try_send((envid_t)a1, (uint32_t)a2, (void *)a3, (unsigned int)a4);
break;
case SYS_ipc_recv:
r = sys_ipc_recv((void *)a1);
break;
default:
r = -E_INVAL;
}
return r;
panic("syscall not implemented");
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
switch (syscallno){
case SYS_getenvid:
return sys_getenvid();
case SYS_cputs:
sys_cputs((const char*)a1, a2);
return 0;
case SYS_cgetc:
return sys_cgetc();
case SYS_env_destroy:
return sys_env_destroy(a1);
case SYS_map_kernel_page:
return sys_map_kernel_page((void*)a1, (void*)a2);
case SYS_sbrk:
return sys_sbrk(a1);
case SYS_yield:
sys_yield();
return 0;
case SYS_exofork:
return sys_exofork();
case SYS_env_set_status:
return sys_env_set_status((envid_t)a1, (int)a2);
case SYS_page_alloc:
return sys_page_alloc((envid_t)a1, (void *)a2,
(int)a3);
case SYS_page_map:
return sys_page_map((envid_t)*((uint32_t*)a1),
(void*)*((uint32_t*)a1+1),
(envid_t)*((uint32_t*)a1+2),
(void*)*((uint32_t*)a1+3),
(int)*((uint32_t*)a1+4));
case SYS_page_unmap:
return sys_page_unmap((envid_t)a1, (void*)a2);
case SYS_env_set_priority:
return sys_env_set_priority((envid_t)a1, (int) a2);
case SYS_env_set_pgfault_upcall:
return sys_env_set_pgfault_upcall((envid_t)a1,
(void*)a2);
case SYS_ipc_recv:
return sys_ipc_recv((void*)a1);
case SYS_ipc_try_send:
return sys_ipc_try_send((envid_t)a1, a2,
(void*)a3, (int)a4);
default:
return -E_INVAL;
}
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
// panic("syscall not implemented");
switch (syscallno) {
case SYS_cputs:
sys_cputs((char *)a1, a2);
break;
case SYS_cgetc:
return sys_cgetc();
case SYS_env_destroy:
return sys_env_destroy(a1);
case SYS_getenvid:
return sys_getenvid();
case SYS_yield:
sys_yield();
break;
case SYS_page_alloc:
return sys_page_alloc(a1, (void *)a2, a3);
case SYS_page_map:
return sys_page_map(a1, (void *)a2, a3, (void *)a4, a5);
case SYS_page_unmap:
return sys_page_unmap(a1, (void *)a2);
case SYS_env_set_status:
return sys_env_set_status(a1, a2);
case SYS_exofork:
return sys_exofork();
case SYS_env_set_pgfault_upcall:
return sys_env_set_pgfault_upcall(a1, (void *)a2);
case SYS_ipc_try_send:
return sys_ipc_try_send(a1, a2, (void*)a3, a4);
case SYS_ipc_recv:
return sys_ipc_recv((void*)a1);
case SYS_env_set_trapframe:
return sys_env_set_trapframe(a1, (struct Trapframe *)a2);
case SYS_time_msec:
return sys_time_msec();
case SYS_trans_pkt:
return sys_trans_pkt((void*)a1, a2);
case SYS_recv_pkt:
return sys_recv_pkt((void *)a1, (size_t *)a2);
default:
return -E_INVAL;
}
return 0;
}
// Dispatches to the correct kernel function, passing the arguments.
int64_t
syscall(uint64_t syscallno, uint64_t a1, uint64_t a2, uint64_t a3, uint64_t a4, uint64_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
uint64_t retval = 0;
switch (syscallno) {
case SYS_cputs:
sys_cputs((char *) a1, (size_t) a2);
return retval;
case SYS_cgetc:
return (int64_t) sys_cgetc();
case SYS_getenvid:
return (int64_t) sys_getenvid();
case SYS_env_destroy:
return (int64_t) sys_env_destroy((envid_t) a1);
case SYS_yield:
sys_yield();
return retval;
case SYS_exofork:
return (int64_t)sys_exofork();
case SYS_page_alloc:
return (int64_t)sys_page_alloc((envid_t)a1, (void *)a2, (int)a3);
case SYS_page_map:
return (int64_t)sys_page_map((envid_t)a1, (void *)a2, (envid_t)a3, (void *)a4, (int)a5);
case SYS_page_unmap:
return (int64_t)sys_page_unmap((envid_t)a1, (void *)a2);
case SYS_env_set_status:
return (int64_t)sys_env_set_status((envid_t)a1, (int)a2);
case SYS_env_set_pgfault_upcall:
return (int64_t)sys_env_set_pgfault_upcall((envid_t)a1, (void *)a2);
case SYS_ipc_try_send:
return (int64_t) sys_ipc_try_send((envid_t) a1, (uint32_t) a2, (void *) a3, (unsigned) a4);
case SYS_ipc_recv:
return (int64_t)sys_ipc_recv((void*)a1);
case SYS_env_set_trapframe:
return sys_env_set_trapframe((envid_t)a1, (struct Trapframe*)a2);
case SYS_time_msec:
return sys_time_msec();
case SYS_net_try_send:
return sys_net_try_send((char *) a1, (int) a2);
case SYS_net_try_receive:
return sys_net_try_receive((char *) a1, (int *) a2);
default:
return -E_INVAL;
}
panic("syscall not implemented");
}
static ssize_t
devcons_read(struct Fd *fd, void *vbuf, size_t n)
{
int c;
if (n == 0)
return 0;
while ((c = sys_cgetc()) == 0)
sys_yield();
if (c < 0)
return c;
if (c == 0x04) // ctl-d is eof
return 0;
*(char*)vbuf = c;
return 1;
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
switch (syscallno) {
case (SYS_cputs):
sys_cputs((const char *) a1, a2);
return 0;
case (SYS_cgetc):
return sys_cgetc();
case (SYS_getenvid):
return sys_getenvid();
case (SYS_env_destroy):
return sys_env_destroy(a1, a2);
case (SYS_yield):
sys_yield();
return 0;
case (SYS_exofork):
return sys_exofork();
case (SYS_env_set_status):
return sys_env_set_status(a1, a2);
case (SYS_page_alloc):
return sys_page_alloc(a1, (void *) a2, a3);
case (SYS_page_map):
return sys_page_map(a1, (void *) a2, a3, (void *) a4, a5);
case (SYS_page_unmap):
return sys_page_unmap(a1, (void *) a2);
case (SYS_env_set_pgfault_upcall):
return sys_env_set_pgfault_upcall(a1, (void *) a2);
case (SYS_ipc_try_send):
return sys_ipc_try_send(a1, a2, (void *) a3, a4);
case (SYS_ipc_recv):
return sys_ipc_recv((void *) a1);
case (SYS_env_set_trapframe):
return sys_env_set_trapframe(a1, (struct Trapframe *) a2);
case (SYS_time_msec):
return sys_time_msec();
case (SYS_e1000_transmit):
return sys_e1000_transmit(a1, (char *) a2, a3);
default:
return -E_INVAL;
}
}
// Dispatches to the correct kernel function, passing the arguments.
uint32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
switch (syscallno){
case SYS_cputs:
sys_cputs( (const char *)a1, a2);
return 0;
case SYS_cgetc:
return sys_cgetc();
case SYS_getenvid:
return sys_getenvid();
case SYS_env_destroy:
return sys_env_destroy(a1);
case SYS_yield:
sys_yield();
return 0;
case SYS_exofork:
return sys_exofork();
case SYS_env_set_status:
return sys_env_set_status(a1, a2);
case SYS_page_alloc:
return sys_page_alloc(a1, (void *)a2, a3);
case SYS_page_map:
return sys_page_map(a1, (void *)a2, a3, (void *)a4, a5);
case SYS_env_set_trapframe:
return sys_env_set_trapframe(a1, (struct Trapframe *)a2);
case SYS_page_unmap:
return sys_page_unmap(a1, (void *)a2);
case SYS_env_set_pgfault_upcall:
return sys_env_set_pgfault_upcall(a1, (void *)a2);
case SYS_ipc_try_send:
return sys_ipc_try_send(a1, a2, (void *)a3, a4);
case SYS_ipc_recv:
return sys_ipc_recv((void *)a1);
default: panic("this syscall ( %d )is not yet implemented", syscallno);
}
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
// My code: gmenghani
// An invalid system call
if(syscallno >= NSYSCALLS)
return -E_INVAL;
switch(syscallno) {
case SYS_cputs: sys_cputs((char *) a1, (size_t)a2);
return 0;
case SYS_cgetc: return sys_cgetc();
case SYS_getenvid: return sys_getenvid();
case SYS_env_destroy: return sys_env_destroy((envid_t)a1);
case SYS_yield : sys_yield(); break;
case SYS_exofork : return sys_exofork();
case SYS_env_set_status : return sys_env_set_status((envid_t)a1, (int)a2);
case SYS_page_alloc : return sys_page_alloc((envid_t)a1, (void*)a2, (int)a3);
case SYS_page_map : return sys_page_map((envid_t)a1, (void*)a2, (envid_t)a3, (void*)a5, (int)a4);
case SYS_page_unmap : return sys_page_unmap((envid_t)a1, (void*)a2);
// For Challenge problem 1 Lab 4a
case SYS_env_set_nice: sys_env_set_nice(a1);
return 0;
case SYS_env_set_pgfault_upcall: sys_env_set_pgfault_upcall((envid_t)a1, (void *)a2);
return 0;
case SYS_ipc_try_send: return sys_ipc_try_send((envid_t)a1, (uint32_t)a2, (void*)a3, (unsigned)a5);
case SYS_ipc_recv: return sys_ipc_recv((void*)a1);
case SYS_env_set_trapframe: return sys_env_set_trapframe((envid_t)a1, (struct Trapframe*)a2);
case SYS_time_msec: return sys_time_msec();
case SYS_net_send: return sys_net_send((void*)a1, (uint32_t) a2);
case SYS_net_recv: return sys_net_recv((void*)a1, (uint16_t*) a2);
}
return 0;
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
//panic("syscall not implemented");
switch (syscallno) {
case SYS_cputs:{
sys_cputs((const char*)a1, a2);
return 0;
}
case SYS_cgetc:
return sys_cgetc();
case SYS_getenvid:
return sys_getenvid();
case SYS_env_destroy:
return sys_env_destroy(curenv->env_id);
default:
return -E_INVAL;
}
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
int32_t ret=0;
/* if(syscallno==SYS_cputs||syscallno==SYS_getenvid||syscallno==SYS_env_destroy||syscallno==SYS_cgetc)
{
if(syscallno==SYS_cputs)
sys_cputs((char *)a1,a2);
if(syscallno==SYS_getenvid)
return sys_getenvid();
if(syscallno==SYS_env_destroy)
return sys_env_destroy(a1);
if(syscallno==SYS_cgetc)
return sys_cgetc();
return ret;
}*/
//cprintf("\nNO----%d\n",syscallno);
switch (syscallno) {
case SYS_cputs:
sys_cputs((const char *)a1, (size_t)a2);
break;
case SYS_cgetc:
ret = sys_cgetc();
break;
case SYS_getenvid:
ret = sys_getenvid();
break;
case SYS_env_destroy:
ret = sys_env_destroy((envid_t)a1);
break;
case SYS_yield:
sys_yield();
break;
case SYS_exofork:
ret=sys_exofork();
break;
case SYS_env_set_status:
ret = sys_env_set_status(a1,a2);
break;
case SYS_page_alloc:
ret = sys_page_alloc(a1,(void *)a2,a3);
break;
case SYS_page_map:
ret = sys_page_map(a1,(void *)a2,a3,(void *)a4,a5);
break;
case SYS_page_unmap:
ret = sys_page_unmap(a1,(void *)a2);
break;
case SYS_env_set_pgfault_upcall:
ret = sys_env_set_pgfault_upcall(a1,(void *)a2);
case SYS_ipc_try_send:
ret=sys_ipc_try_send(a1,a2,(void *)a3,a4);
break;
case SYS_ipc_recv:
ret=sys_ipc_recv((void *)a1);
break;
case SYS_env_set_trapframe:
ret=sys_env_set_trapframe(a1,(struct Trapframe *)a2);
break;
case SYS_time_msec:
ret=sys_time_msec();
break;
case SYS_call_packet_send:
ret=sys_call_packet_send((void *)a1,a2);
break;
case SYS_call_receive_packet:
ret=sys_call_receive_packet((void *)a1,(void *)a2);
break;
default:
// NSYSCALLS
ret = -E_INVAL;
break;
}
return ret;
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
//cprintf("syscallno is %d\n",syscallno);
switch (syscallno){
case SYS_getenvid:
//cprintf("in kernel SYS_getenvid!\n");
return sys_getenvid();
case SYS_cputs:
//cprintf("in kernel SYS_cputs!\n");
sys_cputs((const char*) a1,a2);
return 0;
case SYS_cgetc:
//cprintf("in kernel SYS_cgetc!\n");
return sys_cgetc();
case SYS_env_destroy:
//cprintf("in kernel SYS_env_destroy!\n");
return sys_env_destroy(a1);
case SYS_map_kernel_page:
//cprintf("in kernel SYS_map_kernel_page!\n");
return sys_map_kernel_page((void *)a1, (void *)a2);
case SYS_yield:
//cprintf("in kernel SYS_yield!\n");
//unlock_kernel();
sys_yield();
return 0;
case SYS_page_alloc:
//cprintf("in kernel SYS_page_alloc!\n");
//cprintf("in kern sys_page_alloc!\n");
return sys_page_alloc((envid_t) a1, (void *) a2, (int) a3);
case SYS_page_map:
//cprintf("in kernel SYS_page_map!\n");
//cprintf("in kern sys_page_map!\n");
//cprintf("in kern get arglist is %p\n",a1);
//cprintf("value of a1 is %p\n",*((uint32_t *)a1+1));
return sys_page_map((envid_t) *((uint32_t *)a1), (void *) *((uint32_t *)a1+1),
(envid_t) *((uint32_t *)a1+2), (void *) *((uint32_t *)a1+3), (int) *((uint32_t *)a1+4));
case SYS_page_unmap:
//cprintf("in kernel SYS_page_unmap!\n");
//cprintf("in kern sys_page_unmap!\n");
return sys_page_unmap((envid_t) a1, (void *) a2);
case SYS_exofork:
//cprintf("in kernel SYS_exofork!\n");
//cprintf("in kern sys_exofork!\n");
return sys_exofork();
case SYS_env_set_status:
//cprintf("in kernel SYS_env_set_status!\n");
//cprintf("in kern sys_env_set_status!\n");
//cprintf("syscall in envid %p status %p\n",a1,a2);
return sys_env_set_status((envid_t) a1, (int) a2);
case SYS_env_set_pgfault_upcall:
//cprintf("in kernel SYS_env_set_pgfault_upcall!\n");
return sys_env_set_pgfault_upcall((envid_t) a1, (void *) a2);
case SYS_ipc_recv:
//cprintf("in syscall recive!\n");
return sys_ipc_recv((void*)a1);
case SYS_ipc_try_send:
//cprintf("in syscall send!\n");
return sys_ipc_try_send((envid_t)a1,a2,(void*)a3,(int)a4);
case SYS_proc_save:
return sys_proc_save((envid_t)a1,(struct proc *)a2);
case SYS_proc_resume:
return sys_proc_resume((envid_t)a1,(struct proc*)a2);
default:
return -E_INVAL;
}
// panic("syscall not implemented");
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
// We need to lock the kernel for any calls we know use sysenter
syscall_cond_lock(syscallno, 1);
int32_t ret = 0;
switch(syscallno)
{
case SYS_cputs:
sys_cputs((char *)a1, a2);
break;
case SYS_cgetc:
ret = sys_cgetc();
break;
case SYS_env_destroy:
ret = sys_env_destroy(a1);
break;
case SYS_env_set_pgfault_upcall:
ret = sys_env_set_pgfault_upcall((envid_t)a1, (void*)a2);
break;
case SYS_getenvid:
ret = sys_getenvid();
break;
case SYS_yield:
sys_yield();
break;
case SYS_exofork:
ret = sys_exofork();
break;
case SYS_env_set_status:
ret = sys_env_set_status((envid_t)a1, a2);
break;
case SYS_page_alloc:
ret = sys_page_alloc((envid_t)a1, (void*)a2, a3);
break;
case SYS_page_map:
ret = sys_page_map((envid_t)a1, (void*)a2, (envid_t)a3, (void*)a4, a5);
break;
case SYS_page_unmap:
ret = sys_page_unmap((envid_t)a1, (void*)a2);
break;
case SYS_ipc_try_send:
ret = sys_ipc_try_send((envid_t)a1, (uint32_t)a2,
(void*)a3, (unsigned) a4);
break;
case SYS_ipc_recv:
ret = sys_ipc_recv((void*)a1);
break;
case SYS_env_set_trapframe:
ret = sys_env_set_trapframe((envid_t)a1, (struct Trapframe*)a2);
break;
default:
ret = -E_INVAL;
break;
}
syscall_cond_lock(syscallno, 0);
return ret;
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
uint32_t result = -E_INVAL;
//cprintf("syscallno:%08x\n",syscallno);
switch(syscallno)
{
case SYS_cputs:
sys_cputs((char *)a1,(size_t)a2);
result = SYS_cputs;
break;
case SYS_getenvid:
result = sys_getenvid();
break;
case SYS_cgetc:
result = sys_cgetc();
break;
case SYS_env_destroy:
result = sys_env_destroy((envid_t)a1);
break;
case SYS_env_set_trapframe:
result = sys_env_set_trapframe((envid_t)a1, (struct Trapframe *)a2);
break;
case SYS_yield:
sys_yield();
result = SYS_yield;
break;
case SYS_exofork:
result = sys_exofork();
break;
case SYS_env_set_status:
result = sys_env_set_status((envid_t)a1,(int)a2);
break;
case SYS_page_alloc:
result = sys_page_alloc((envid_t)a1,(void *)a2,(int)a3);
break;
case SYS_page_map:
result = sys_page_map((envid_t)a1,(void *)a2,(envid_t)a3,(void *)a4,(int)a5);
break;
case SYS_page_unmap:
result = sys_page_unmap((envid_t)a1,(void *)a2);
break;
case SYS_env_set_pgfault_upcall:
result = sys_env_set_pgfault_upcall((envid_t)a1,(void*)a2);
break;
case SYS_ipc_recv:
result = sys_ipc_recv((void*)a1);
break;
case SYS_ipc_try_send:
result = sys_ipc_try_send((envid_t)a1, (uint32_t)a2, (void *)a3, (unsigned)a4);
break;
case SYS_for_fork:
result = sys_for_fork((envid_t)a1, (void *)a2, (int)a3);
break;
case SYS_set_shforkid:
result = sys_set_shforkid((envid_t)a1);
break;
default:
result = -E_INVAL;
}
return result;
}
// Dispatches to the correct kernel function, passing the arguments.
int64_t
syscall(uint64_t syscallno, uint64_t a1, uint64_t a2, uint64_t a3, uint64_t a4, uint64_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
int64_t returnVal = -E_INVAL;
if(syscallno == SYS_cputs){
sys_cputs((char *)a1,(size_t)a2);
returnVal = 0;
}
if(syscallno == SYS_cgetc){
returnVal = (uint64_t)sys_cgetc();
}
if(syscallno == SYS_getenvid){
returnVal = (uint64_t)sys_getenvid();
}
if(syscallno == SYS_env_destroy){
returnVal = (uint64_t)sys_env_destroy((envid_t)a1);
}
if(syscallno == SYS_yield){
sys_yield();
returnVal = 0;
}
if(syscallno == SYS_exofork){
returnVal = (uint64_t)sys_exofork();
}
if(syscallno == SYS_env_set_status){
returnVal = (uint64_t)sys_env_set_status((envid_t)a1,(uint64_t)a2);
}
if(syscallno == SYS_page_alloc){
returnVal = (uint64_t)sys_page_alloc((envid_t)a1,(uint64_t *)a2,(int)a3);
}
if(syscallno == SYS_page_map){
returnVal = (uint64_t)sys_page_map((envid_t)a1,(uint64_t *)a2,(envid_t)a3,(uint64_t *)a4,(int)a5);
}
if(syscallno == SYS_page_unmap){
returnVal = (uint64_t)sys_page_unmap((envid_t)a1,(uint64_t *)a2);
}
if(syscallno == SYS_env_set_pgfault_upcall){
returnVal = (uint64_t)sys_env_set_pgfault_upcall((envid_t)a1,(void *)a2);
}
if(syscallno == SYS_ipc_try_send){
returnVal = (uint64_t)sys_ipc_try_send((envid_t)a1,(uint32_t)a2,(void *)a3,(unsigned)a4);
}
if(syscallno == SYS_ipc_recv){
returnVal = (uint64_t)sys_ipc_recv((void *)a1);
}
if(syscallno == SYS_env_set_trapframe){
returnVal = (uint64_t)sys_env_set_trapframe((envid_t)a1, (struct Trapframe *)a2);
}
if(syscallno == SYS_env_set_transaction){
returnVal = (uint64_t)sys_set_transaction((envid_t)a1,(void *)a2);
}
if(syscallno == SYS_init_journ){
returnVal = (uint64_t)sys_init_journ();
}
return returnVal;
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
switch (syscallno) {
case SYS_cputs :
sys_cputs((const char*) a1, (size_t) a2);
return 0;
case SYS_env_set_trapframe:
return sys_env_set_trapframe((envid_t)a1, (struct Trapframe*) a2);
case SYS_cgetc :
return sys_cgetc();
case SYS_getenvid:
return sys_getenvid();
case SYS_env_destroy:
return sys_env_destroy((envid_t) a1);
case SYS_yield:
sys_yield();
return 0;
case SYS_exofork:
return sys_exofork();
case SYS_env_set_status:
return sys_env_set_status((envid_t)a1,(int)a2);
case SYS_page_alloc:
return sys_page_alloc((envid_t)a1, (void *)a2, (int)a3);
case SYS_page_map:
return sys_page_map((envid_t)a1, (void *)a2, (envid_t)a3, (void *)a4, (int)a5);
case SYS_page_unmap:
return sys_page_unmap((envid_t)a1, (void *)a2);
case SYS_env_set_pgfault_upcall:
return sys_env_set_pgfault_upcall((envid_t)a1, (void *)a2);
case SYS_ipc_try_send:
//cprintf("Sending ipc..\n\n\n");
return sys_ipc_try_send((envid_t)a1, (uint32_t)a2, (void *)a3, (unsigned)a4);
case SYS_ipc_recv:
return sys_ipc_recv((void *)a1);
case SYS_clear_block_access_bit:
return sys_clear_block_access_bit((envid_t)a1, (void*) a2);
case SYS_time_msec:
return sys_time_msec();
case SYS_send_packet:
return sys_send_packet((void *)a1, (unsigned)a2);
case SYS_receive_packet:
return sys_receive_packet((void *)a1);
case SYS_get_mac_address:
return sys_get_mac_address((uint8_t *) a1);
case SYS_get_logged_user_name:
return sys_get_logged_user_name((char *)a1);
case SYS_get_current_path:
return sys_get_current_path((char *)a1);
case SYS_update_current_path:
return sys_update_current_path((char *)a1);
case SYS_get_home_dir:
return sys_get_home_dir((char *)a1);
default:
return -E_INVAL;
}
//panic("syscall not implemented");
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
switch(syscallno){
case SYS_cputs:
user_mem_assert(curenv, (void *)a1, a2, PTE_U);
sys_cputs((char *)a1, a2);
return 0;
break;
case SYS_cgetc:
return sys_cgetc();
break;
case SYS_getenvid:
return sys_getenvid();
break;
case SYS_getenv_parent_id:
return sys_getenv_parent_id(a1);
break;
case SYS_env_destroy:
return sys_env_destroy(a1);
break;
case SYS_page_alloc:
return sys_page_alloc(a1, (void *)a2, a3);
break;
case SYS_page_map:
return sys_page_map(a1, (void *)a2, a3, (void *)a4, a5);
break;
case SYS_page_unmap:
return sys_page_unmap(a1, (void *)a2);
break;
case SYS_exofork:
return sys_exofork();
break;
case SYS_env_set_status:
return sys_env_set_status(a1, a2);
break;
case SYS_env_set_trapframe:
return sys_env_set_trapframe(a1, (struct Trapframe *)a2);
break;
case SYS_env_set_pgfault_upcall:
return sys_env_set_pgfault_upcall(a1, (void *)a2);
break;
case SYS_env_get_curdir:
return sys_env_get_curdir((envid_t)a1, (char *)a2);
break;
case SYS_env_set_curdir:
return sys_env_set_curdir((envid_t)a1, (char *)a2);
break;
case SYS_yield:
sys_yield();
break;
case SYS_ipc_try_send:
return sys_ipc_try_send(a1, a2, (void *)a3, a4);
break;
case SYS_ipc_recv:
return sys_ipc_recv((void *)a1);
break;
case SYS_time_msec:
return sys_time_msec();
break;
case SYS_net_send:
return sys_net_send((void *)a1, a2);
break;
case SYS_net_recv:
return sys_net_recv((void *)a1, a2);
break;
case NSYSCALLS:
default:
return -E_INVAL;
break;
}
return 0;
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
/*stone's solution for lab3-B*/
int32_t ret = -E_INVAL;
switch (syscallno){
case SYS_cputs:
sys_cputs((char*)a1, a2);
ret = 0;
break;
case SYS_cgetc:
ret = sys_cgetc();
break;
case SYS_getenvid:
ret = sys_getenvid();
break;
case SYS_env_destroy:
ret = sys_env_destroy(a1);
break;
case SYS_map_kernel_page:
ret = sys_map_kernel_page((void*)a1, (void*)a2);
break;
case SYS_sbrk:
ret = sys_sbrk(a1);
break;
/*stone's solution for lab4-A*/
case SYS_yield:
sys_yield();
ret = 0;
break;
case SYS_exofork:
ret = sys_exofork();
break;
case SYS_env_set_status:
ret = sys_env_set_status(a1, a2);
break;
case SYS_env_set_pgfault_upcall:
ret = sys_env_set_pgfault_upcall((envid_t)a1, (void*)a2);
break;
case SYS_page_alloc:
ret = sys_page_alloc((envid_t)a1, (void*)a2, (int)a3);
break;
case SYS_page_map:
/*stone: see lib/syscall.c for modification details*/
ret = sys_page_map(*((uint32_t*)a1), (void*)*((uint32_t*)a1 + 1), *((uint32_t*)a1 + 2), (void*)*((uint32_t*)a1 + 3), *((uint32_t*)a1 + 4));
//ret = sys_page_map(a1, (void*)a2, a3, (void*)a4, a5);
break;
case SYS_page_unmap:
ret = sys_page_unmap(a1, (void*)a2);
break;
case SYS_ipc_recv:
ret = sys_ipc_recv((void*)a1);
break;
case SYS_ipc_try_send:
ret = sys_ipc_try_send((envid_t)a1, a2, (void*)a3, (int)a4);
break;
case SYS_env_set_trapframe:
ret = sys_env_set_trapframe((envid_t)a1, (struct Trapframe*)a2);
break;
default:
break;
}
return ret;
//panic("syscall not implemented");
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
switch(syscallno) {
case SYS_cputs:
sys_cputs((char *) a1, (size_t) a2);
break;
case SYS_cgetc:
return sys_cgetc();
case SYS_getenvid:
return sys_getenvid();
case SYS_env_destroy:
return sys_env_destroy((envid_t) a1);
case SYS_yield:
sys_yield();
break;
case SYS_exofork:
return sys_exofork();
case SYS_env_set_status:
return sys_env_set_status((envid_t) a1, (int) a2);
case SYS_env_set_trapframe:
return sys_env_set_trapframe((envid_t) a1, (struct Trapframe *) a2);
case SYS_page_alloc:
return sys_page_alloc((envid_t) a1, (void *) a2, (int) a3);
case SYS_page_map:
return sys_page_map((envid_t) a1, (void *) a2,
(envid_t) a3, (void *) a4, (int) a5);
case SYS_page_unmap:
return sys_page_unmap((envid_t) a1, (void *) a2);
case SYS_env_set_pgfault_upcall:
return sys_env_set_pgfault_upcall((envid_t) a1, (void *) a2);
case SYS_ipc_try_send:
return sys_ipc_try_send((envid_t) a1, (uint32_t) a2, (void *) a3, (unsigned) a4);
case SYS_ipc_recv:
return sys_ipc_recv((void *) a1);
case SYS_env_swap:
return sys_env_swap((envid_t) a1);
case SYS_time_msec:
return sys_time_msec();
case SYS_net_try_send:
return sys_net_try_send((char *) a1, (int) a2);
case SYS_net_try_receive:
return sys_net_try_receive((char *) a1, (int *) a2);
case SYS_get_mac:
return sys_get_mac((uint32_t *) a1, (uint32_t *) a2);
case SYS_env_lease:
return sys_env_lease((struct Env*) a1, (envid_t *) a2);
case SYS_copy_mem:
return sys_copy_mem((envid_t) a1, (void *) a2, (void *) a3,
(int) a4, (bool) a5);
case SYS_get_perms:
return sys_get_perms((envid_t) a1, (void *) a2, (int *) a3);
case SYS_env_unsuspend:
return sys_env_unsuspend((envid_t) a1, (uint32_t) a2, (uint32_t) a3);
case SYS_env_set_thisenv:
return sys_env_set_thisenv((envid_t) a1, (void *) a2);
case SYS_migrate:
return sys_migrate((void *) a1);
case SYS_lease_complete:
return sys_lease_complete();
default:
return -E_INVAL;
}
return 0; // for syscall that return void
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
int32_t ret = 0;
switch (syscallno) {
case SYS_cputs:
sys_cputs((char *)a1, (size_t)a2);
break;
case SYS_cgetc:
ret = sys_cgetc();
break;
case SYS_getenvid:
ret = sys_getenvid();
break;
case SYS_env_destroy:
ret = sys_env_destroy((envid_t)a1);
break;
case SYS_yield:
sys_yield();
break;
case SYS_exofork:
ret = sys_exofork();
break;
case SYS_env_set_status:
ret = sys_env_set_status((envid_t)a1, a2);
break;
case SYS_page_alloc:
ret = sys_page_alloc((envid_t)a1, (void *)a2, a3);
break;
case SYS_page_map:
ret = sys_page_map((envid_t)a1, (void *)a2, (envid_t)a3, (void *)a4, a5);
break;
case SYS_page_unmap:
ret = sys_page_unmap((envid_t)a1, (void *)a2);
break;
case SYS_env_set_pgfault_upcall:
ret = sys_env_set_pgfault_upcall((envid_t)a1, (void *)a2);
break;
case SYS_ipc_recv:
ret = sys_ipc_recv((void *)a1);
break;
case SYS_ipc_try_send:
ret = sys_ipc_try_send((envid_t)a1, (uint32_t)a2, (void *)a3, (unsigned)a4);
break;
case SYS_env_set_trapframe:
ret = sys_env_set_trapframe((envid_t)a1, (struct Trapframe *)a2);
break;
case SYS_time_msec:
ret = sys_time_msec();
break;
case SYS_transmit_packet:
ret = sys_transmit_packet((void *)a1, a2);
break;
case SYS_receive_packet:
ret = sys_receive_packet((void *)a1);
break;
default:
return -E_INVAL;
}
return ret;
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
// Call the function corresponding to the 'syscallno' parameter.
// Return any appropriate return value.
// LAB 3: Your code here.
int32_t res;
a5 = syscallno >> 8;
syscallno -= (a5<<8);
//if(a5!=0)cprintf("syscallno %d %x %x\n",syscallno,a1,a5);
switch(syscallno)
{
case SYS_cputs:
sys_cputs((const char*)a1,(size_t)a2);
res = 0;
break;
case SYS_cgetc:
res = sys_cgetc();
break;
case SYS_getenvid:
res = sys_getenvid();
break;
case SYS_env_destroy:
res = sys_env_destroy(a1);
break;
case SYS_map_kernel_page:
res = sys_map_kernel_page((void*)a1,(void*)a2);
break;
case SYS_yield:
res = 0;
sys_yield();
break;
case SYS_exofork:
res = sys_exofork();
break;
case SYS_env_set_status:
res = sys_env_set_status(a1,a2);
break;
case SYS_page_alloc:
res = sys_page_alloc(a1,(void*)a2,a3);
break;
case SYS_page_map:
res = sys_page_map(a1,(void*)a2,a3,(void*)a4,(int)a5);
break;
case SYS_page_unmap:
res = sys_page_unmap(a1,(void*)a2);
break;
case SYS_env_set_pgfault_upcall:
res = sys_env_set_pgfault_upcall(a1,(void*)a2);
break;
case SYS_ipc_try_send:
res = sys_ipc_try_send(a1,a2,(void*)a3,a4);
break;
case SYS_ipc_recv:
res = sys_ipc_recv((void*)a1);
break;
case NSYSCALLS:
default:
res = -E_INVAL;
}
//cprintf("res %x\n",res);
return res;
}
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
switch (syscallno) {
case SYS_cputs:
sys_cputs((char *)a1, a2);
return 0; /* Sys_cputs is of no interest in return-value */
case SYS_cgetc:
return sys_cgetc();
case SYS_reboot:
sys_reboot();
return 0;
case SYS_env_destroy:
return sys_env_destroy(a1);
case SYS_getenvid:
return sys_getenvid();
case SYS_yield:
sys_yield(); /* Never return */
case SYS_page_alloc:
return sys_page_alloc((envid_t)a1, (void *)a2, (int)a3);
case SYS_page_map:
return sys_page_map((envid_t)a1, (void *)a2, (envid_t)a3, (void *)a4, (int)a5);
case SYS_page_unmap:
return sys_page_unmap((envid_t)a1, (void *)a2);
case SYS_exofork:
return sys_exofork();
case SYS_env_set_status:
return sys_env_set_status((envid_t)a1, (int)a2);
case SYS_env_set_trapframe:
return sys_env_set_trapframe((envid_t)a1, (struct Trapframe *)a2);
case SYS_env_set_pgfault_upcall:
return sys_env_set_pgfault_upcall((envid_t)a1, (void *)a2);
case SYS_ipc_try_send:
return sys_ipc_try_send((envid_t)a1, (uint32_t)a2, (void *)a3, (unsigned)a4);
case SYS_ipc_recv:
return sys_ipc_recv((void *)a1); /* Never return */
case SYS_time_msec:
return sys_time_msec();
case SYS_nic_send:
return sys_nic_send((char *)a1, (int)a2);
case SYS_nic_recv:
return sys_nic_recv((char *)a1, (int *)a2);
default:
panic("Unknown system call!");
}
}
