// Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'. // This function keeps trying until it succeeds. // It should panic() on any error other than -E_IPC_NOT_RECV. // // Hint: // Use sys_yield() to be CPU-friendly. // If 'pg' is null, pass sys_ipc_recv a value that it will understand // as meaning "no page". (Zero is not the right value.) void ipc_send(envid_t to_env, uint32_t val, void *pg, int perm) { // LAB 4: Your code here. //panic("ipc_send not implemented"); int result; if(pg == NULL) { result=sys_ipc_try_send(to_env, val, (void *)UTOP, perm); } else { result=sys_ipc_try_send(to_env, val, pg, perm); } while(result < 0) { if(result != -E_IPC_NOT_RECV) { panic ("ipc send error!"); } sys_yield (); if(pg == NULL) { result=sys_ipc_try_send(to_env, val, (void *)UTOP, perm); } else { result=sys_ipc_try_send(to_env, val, pg, perm); } } }
// Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'. // This function keeps trying until it succeeds. // It should panic() on any error other than -E_IPC_NOT_RECV. // // Hint: // Use sys_yield() to be CPU-friendly. // If 'pg' is null, pass sys_ipc_recv a value that it will understand // as meaning "no page". (Zero is not the right value.) void ipc_send(envid_t to_env, uint32_t val, void *pg, int perm) { int r; if (pg == NULL) pg = (void *)UTOP; do { int r = sys_ipc_try_send(to_env, val, pg, perm); switch (r) { case 0: case 1: return; case -E_IPC_NOT_RECV: sys_yield(); continue; default: panic("sys_ipc_try_send(%08x, %u, %08x, %d) failed: %e\n", to_env, val, pg, perm, r); } } while (1); }
void input(envid_t ns_envid) { binaryname = "ns_input"; // LAB 6: Your code here: // - read a packet from the device driver // - send it to the network server // Hint: When you IPC a page to the network server, it will be // reading from it for a while, so don't immediately receive // another packet in to the same physical page. int RPKT_SIZE = 2048; int lengthOfPacket = RPKT_SIZE - 1; int r = 0; char buffer[RPKT_SIZE]; while(1){ while((r = sys_receive(buffer,&lengthOfPacket))<0){ sys_yield(); } while((r = sys_page_alloc(0, &nsipcbuf, PTE_P|PTE_U|PTE_W))<0); nsipcbuf.pkt.jp_len = lengthOfPacket; memmove(nsipcbuf.pkt.jp_data, buffer, lengthOfPacket); while((r = sys_ipc_try_send(ns_envid, NSREQ_INPUT, &nsipcbuf, PTE_P|PTE_U|PTE_W)) < 0); } }
// Send 'val' (and 'pg' with 'perm', assuming 'pg' is nonnull) to 'toenv'. // This function keeps trying until it succeeds. // It should panic() on any error other than -E_IPC_NOT_RECV. // // Hint: // Use sys_yield() to be CPU-friendly. // If 'pg' is null, pass sys_ipc_recv a value that it will understand // as meaning "no page". (Zero is not the right value.) void ipc_send(envid_t to_env, uint32_t val, void *pg, int perm) { // LAB 4: Your code here. int ret; void * srcva; if(pg == 0) srcva = (void*)UTOP; else srcva = pg; while(1) { ret = sys_ipc_try_send(to_env,val,srcva,perm); if(ret == 0 || ret == 1) { //cprintf("return 0\n"); sys_yield(); break; } else if(ret == -E_IPC_NOT_RECV) { //cprintf("ipc not recv\n"); sys_yield(); continue; } else panic("error occur in ipc send:%e",ret); } //cprintf("return from ipc send\n"); //panic("ipc_send 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"); 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; } }
// Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'. // This function keeps trying until it succeeds. // It should panic() on any error other than -E_IPC_NOT_RECV. // // Hint: // Use sys_yield() to be CPU-friendly. // If 'pg' is null, pass sys_ipc_try_send a value that it will understand // as meaning "no page". (Zero is not the right value.) void ipc_send(envid_t to_env, uint32_t val, void *pg, int perm) { // LAB 4: Your code here. struct Env *env; int r; void *srcva; if (pg == NULL) { srcva = (void *)~0; } else { srcva = pg; } IPC_DEBUG("ipc_send: perm = %d\n", perm); while ((r = sys_ipc_try_send(to_env, val, srcva, perm)) != 0) { if (r != -E_IPC_NOT_RECV) { panic("ipc_send: sys_ipc_try_send erro %e\n", r); } } // I tested and found out a sys_yield() here actually made things slower! // sys_yield(); return; }
void input(envid_t ns_envid) { binaryname = "ns_input"; // LAB 6: Your code here: // - read a packet from the device driver // - send it to the network server // Hint: When you IPC a page to the network server, it will be // reading from it for a while, so don't immediately receive // another packet in to the same physical page. uint8_t data[2048]; int length, r; for (;;) { while ((length = sys_pkt_receive(data)) < 0) sys_yield(); while (sys_page_alloc(0, &nsipcbuf, PTE_P | PTE_W | PTE_U) < 0) sys_yield(); nsipcbuf.pkt.jp_len = length; memmove(nsipcbuf.pkt.jp_data, data, length); while (sys_ipc_try_send(ns_envid, NSREQ_INPUT, &nsipcbuf, PTE_P | PTE_W | PTE_U) < 0) sys_yield(); } }
// Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'. // This function keeps trying until it succeeds. // It should panic() on any error other than -E_IPC_NOT_RECV. // // Hint: // Use sys_yield() to be CPU-friendly. // If 'pg' is null, pass sys_ipc_recv a value that it will understand // as meaning "no page". (Zero is not the right value.) void ipc_send(envid_t to_env, uint32_t val, void *pg, int perm) { // LAB 4: Your code here. //panic("ipc_send not implemented"); /* lj */ int ret = 0; void *addr = NULL; addr = pg ? pg : (void *)-1; //cprintf("%x->%x [%d]\n", thisenv->env_id, to_env, val); while (1) { if(-E_IPC_NOT_RECV == ret) { sys_yield(); } ret = sys_ipc_try_send(to_env, val, addr, perm); if(0 == ret) { break; } else if(-E_IPC_NOT_RECV == ret) { //cprintf("%x continue\n", thisenv->env_id); continue; } else if(ret < 0) { panic("ipc_send error:%e", 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. 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"); }
// 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; }
// Send 'val' (and 'pg' with 'perm', assuming 'pg' is nonnull) to 'toenv'. // This function keeps trying until it succeeds. // It should panic() on any error other than -E_IPC_NOT_RECV. void ipc_send(envid_t to_env, uint32_t val, void *pg, int perm) { int r; while (( r = sys_ipc_try_send(to_env, val, pg, perm)) == -E_IPC_NOT_RECV) { sys_yield(); } if (r < 0) panic("icp_send %e", 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. 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"); }
// Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'. // This function keeps trying until it succeeds. // It should panic() on any error other than -E_IPC_NOT_RECV. // // Hint: // Use sys_yield() to be CPU-friendly. // If 'pg' is null, pass sys_ipc_try_send a value that it will understand // as meaning "no page". (Zero is not the right value.) void ipc_send(envid_t to_env, uint32_t val, void *pg, int perm) { // LAB 4: Your code here. // panic("ipc_send not implemented"); int r; void *srcva = pg?pg:(void*)UTOP; while ((r = sys_ipc_try_send(to_env, val, srcva, perm))) { if (r != -E_IPC_NOT_RECV) panic("sys_ipc_try_send fail:%e, pg:%#0x, perm:%d\n", r, (int)pg, perm); sys_yield(); } }
// Send 'val' (and 'pg' with 'perm', assuming 'pg' is nonnull) to 'toenv'. // This function keeps trying until it succeeds. // It should panic() on any error other than -E_IPC_NOT_RECV. // // Hint: // Use sys_yield() to be CPU-friendly. // If 'pg' is null, pass sys_ipc_recv a value that it will understand // as meaning "no page". (Zero is not the right value.) void ipc_send(envid_t to_env, uint32_t val, void *pg, int perm) { // LAB 4: Your code here. int ret; dprintk("[IPC] send from %08x to %08x, value=%d, pg=%p, perm=%x\n", sys_getenvid(), to_env, val, pg, perm); while (1) { if (pg == NULL) { /* TODO: allow pg=0 */ ret = sys_ipc_try_send(to_env, val, (void *) -1, 0); } else { ret = sys_ipc_try_send(to_env, val, pg, perm); } if (ret == 0 || ret == 1) break; if (ret != -E_IPC_NOT_RECV) panic("ipc_send error %e", 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. // 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. 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; } }
// Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'. // This function keeps trying until it succeeds. // It should panic() on any error other than -E_IPC_NOT_RECV. // // Hint: // Use sys_yield() to be CPU-friendly. // If 'pg' is null, pass sys_ipc_try_send a value that it will understand // as meaning "no page". (Zero is not the right value.) void ipc_send(envid_t to_env, uint32_t val, void *pg, int perm) { // LAB 4: Your code here. int result = -E_IPC_NOT_RECV ; if ( pg ) result = sys_ipc_try_send( to_env , val , pg , perm ) ; else result = sys_ipc_try_send( to_env , val , (void*)UTOP , perm ) ; if ( result == 0 ) return ; if ( result == -E_IPC_NOT_RECV ) { if ( pg ) result = sys_ipc_try_send( to_env , val , pg , perm ) ; else result = sys_ipc_try_send( to_env , val , (void*)UTOP , perm ) ; if ( result == 0 ) return ; } panic("ipc_send error %e.",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. 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"); }
// Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'. // This function keeps trying until it succeeds. // It should panic() on any error other than -E_IPC_NOT_RECV. // // Hint: // Use sys_yield() to be CPU-friendly. // If 'pg' is null, pass sys_ipc_recv a value that it will understand // as meaning "no page". (Zero is not the right value.) void ipc_send(envid_t to_env, uint32_t val, void *pg, int perm) { // LAB 4: Your code here. int r; if(!pg) pg = (void*)UTOP; while((r = sys_ipc_try_send(to_env,val,pg,perm)) != 0) { if(/* r < 0 && */r != -E_IPC_NOT_RECV ) panic ("ipc: sys try send failed : %e", r); } sys_yield(); }
// Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'. // This function keeps trying until it succeeds. // It should panic() on any error other than -E_IPC_NOT_RECV. // // Hint: // Use sys_yield() to be CPU-friendly. // If 'pg' is null, pass sys_ipc_recv a value that it will understand // as meaning "no page". (Zero is not the right value.) void ipc_send(envid_t to_env, uint32_t val, void *pg, int perm) { // LAB 4: Your code here. //panic("ipc_send not implemented"); int ret; pg = (pg == NULL ? (void*)UTOP : pg); while((ret = sys_ipc_try_send(to_env,val,pg,perm))<0) { if(ret != -E_IPC_NOT_RECV) panic("sys_ipc_try_send in ipc_send: %e",ret); //cprintf("Sending fialeddddddddddddddd\n\n\n\n\n"); sys_yield(); } }
// Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'. // This function keeps trying until it succeeds. // It should panic() on any error other than -E_IPC_NOT_RECV. // // Hint: // Use sys_yield() to be CPU-friendly. // If 'pg' is null, pass sys_ipc_recv a value that it will understand // as meaning "no page". (Zero is not the right value.) void ipc_send(envid_t to_env, uint32_t val, void *pg, int perm) { //cprintf("to_env: %08x from_env: %08x\n", to_env, thisenv->env_id); int ret = -E_IPC_NOT_RECV; if (!pg) pg = (void *)UTOP; while (true) { ret = sys_ipc_try_send(to_env,val,pg,perm); if (ret == 0) return; if (ret != -E_IPC_NOT_RECV) break; sys_yield(); } panic("Send failed: %e", ret); }
// Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'. // This function keeps trying until it succeeds. // It should panic() on any error other than -E_IPC_NOT_RECV. // // Hint: // Use sys_yield() to be CPU-friendly. // If 'pg' is null, pass sys_ipc_recv a value that it will understand // as meaning "no page". (Zero is not the right value.) void ipc_send(envid_t to_env, uint32_t val, void *pg, int perm) { // LAB 4: Your code here. int r; if(pg == NULL) pg = (void *)~0x0; while((r = sys_ipc_try_send(to_env, val, pg, perm)) < 0){ if(r != -E_IPC_NOT_RECV) panic("Send message error %e\n",r); sys_yield(); } // panic("ipc_send not implemented"); }
// Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'. // This function keeps trying until it succeeds. // It should panic() on any error other than -E_IPC_NOT_RECV. // // Hint: // Use sys_yield() to be CPU-friendly. // If 'pg' is null, pass sys_ipc_recv a value that it will understand // as meaning "no page". (Zero is not the right value.) void ipc_send(envid_t to_env, uint32_t val, void *pg, int perm) { // LAB 4: Your code here. int r; if (pg == NULL) pg = (void*)UTOP; while ((r = sys_ipc_try_send(to_env, val, pg, perm)) < 0) { if(r != -E_IPC_NOT_RECV) panic("Panic in lib ipc.c : ipc_send() \n"); sys_yield(); } //panic("ipc_send not implemented"); }
// Send 'val' (and 'pg' with 'perm', assuming 'pg' is nonnull) to 'toenv'. // This function keeps trying until it succeeds. // It should panic() on any error other than -E_IPC_NOT_RECV. // // Hint: // Use sys_yield() to be CPU-friendly. // If 'pg' is null, pass sys_ipc_recv a value that it will understand // as meaning "no page". (Zero is not the right value.) void ipc_send(envid_t to_env, uint32_t val, void *pg, int perm) { // LAB 4: Your code here. int r; while ((r = sys_ipc_try_send(to_env, val, pg != NULL ? pg : (void *)UTOP, perm)) < 0){ if (r != -E_IPC_NOT_RECV){ panic("lib ipc_send failed. returned %d\n", r); } sys_yield(); } // panic("ipc_send 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((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; } }
// Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'. // This function keeps trying until it succeeds. // It should panic() on any error other than -E_IPC_NOT_RECV. // // Hint: // Use sys_yield() to be CPU-friendly. // If 'pg' is null, pass sys_ipc_recv a value that it will understand // as meaning "no page". (Zero is not the right value.) void ipc_send(envid_t to_env, uint32_t val, void *pg, int perm) { // LAB 4: Your code here. if(!pg) pg = (void*)0xFFFFFFFF; // No need to loop due to LAB 4 CHALLENGE int ret; ret = sys_ipc_try_send(to_env, val, pg, perm); if(ret != 0) panic("ipc_send got unknown error %d: %e\n", ret, ret); }
// Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'. // This function keeps trying until it succeeds. // It should panic() on any error other than -E_IPC_NOT_RECV. void ipc_send(envid_t to_env, uint32_t val, void *pg, int perm) { // If 'pg' is null, pass sys_ipc_recv a value that it will understand // as meaning "no page". (Zero is not the right value.) void *srcva = pg ? pg : (void *)UTOP; int r; while (1) { r = sys_ipc_try_send(to_env, val, srcva, perm); if (r == -E_IPC_NOT_RECV) // Use sys_yield() to be CPU-friendly. sys_yield(); else if (r < 0) panic("sys_ipc_try_send: %e\n", r); else return; } }
// 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); } }
// Send 'val' (and 'pg' with 'perm', if 'pg' is nonnull) to 'toenv'. // This function keeps trying until it succeeds. // It should panic() on any error other than -E_IPC_NOT_RECV. // // Hint: // Use sys_yield() to be CPU-friendly. // If 'pg' is null, pass sys_ipc_recv a value that it will understand // as meaning "no page". (Zero is not the right value.) void ipc_send(envid_t to_env, uint32_t val, void *pg, int perm) { // LAB 4: Your code here. // seanyliu //panic("ipc_send not implemented"); int r; if (pg == NULL) { pg = (void *) UTOP; perm = 0; } while (1) { r = sys_ipc_try_send(to_env, val, pg, perm); if (r == -E_IPC_NOT_RECV) { sys_yield(); } else if (r < 0) panic ("ipc_send: failed to send: %d", r); else break; } }