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!"); } }