void
sleep(int sec)
{
unsigned end = sys_time_msec() + sec * 1000;
while (sys_time_msec() < end)
sys_yield();
}
void
timer(envid_t ns_envid, uint32_t initial_to) {
int r;
uint32_t stop = sys_time_msec() + initial_to;
binaryname = "ns_timer";
while (1) {
while((r = sys_time_msec()) < stop && r >= 0) {
sys_yield();
}
if (r < 0)
panic("sys_time_msec: %e", r);
ipc_send(ns_envid, NSREQ_TIMER, 0, 0);
while (1) {
uint32_t to, whom;
to = ipc_recv((int32_t *) &whom, 0, 0);
if (whom != ns_envid) {
cprintf("NS TIMER: timer thread got IPC message from env %x not NS\n", whom);
continue;
}
stop = sys_time_msec() + to;
break;
}
}
}
void
static msleep(int msec)
{
unsigned now = sys_time_msec();
unsigned end = now + msec;
if ((int)now < 0 && (int)now > -MAXERROR)
panic("sys_time_msec: %e", (int)now);
if (end < now)
panic("sleep: wrap");
while (sys_time_msec() < end)
sys_yield();
}
// 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;
}
}
static void
process_timer(envid_t envid) {
uint32_t start, now, to;
if (envid != timer_envid) {
cprintf("NS: received timer interrupt from envid %x not timer env\n", envid);
return;
}
start = sys_time_msec();
thread_yield();
now = sys_time_msec();
to = TIMER_INTERVAL - (now - start);
ipc_send(envid, to, 0, 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.
// 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");
}
void
thread_wait(volatile uint32_t *addr, uint32_t val, uint32_t msec) {
uint32_t s = sys_time_msec();
uint32_t p = s;
cur_tc->tc_wait_addr = addr;
cur_tc->tc_wakeup = 0;
while (p < msec) {
if (p < s)
break;
if (addr && *addr != val)
break;
if (cur_tc->tc_wakeup)
break;
thread_yield();
p = sys_time_msec();
}
cur_tc->tc_wait_addr = 0;
cur_tc->tc_wakeup = 0;
}
net_timer(uint32_t arg)
{
struct timer_thread *t = (struct timer_thread *) arg;
for (;;) {
uint32_t cur = sys_time_msec();
lwip_core_lock();
t->func();
lwip_core_unlock();
thread_wait(0, 0, cur + t->msec);
}
}
// 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.
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;
}
//=======
//>>>>>>> new_lab5
// 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;
/*stone's solution for lab5*/
case SYS_env_set_trapframe:
ret = sys_env_set_trapframe((envid_t)a1, (struct Trapframe*)a2);
break;
/*stone's solution for lab6-A*/
case SYS_time_msec:
ret = sys_time_msec();
break;
case SYS_transmit:
ret = sys_transmit((uint8_t*)a1, (uint32_t)a2);
break;
case SYS_receive:
ret = sys_receive((uint8_t*)a1, (uint32_t*)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.
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.
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.
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.
// 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;
/* 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)
{
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!");
}
}
