int __remap_reserved_page(u_int va, u_int pte_flags) { u_int i; for (i=0; i < __eea->eea_reserved_pages; i++) { if ((vpt[PGNO((u_int)__eea->eea_reserved_first) + i] & PG_P)) { if (_exos_self_insert_pte(CAP_ROOT, ppnf2pte(PGNO(vpt[PGNO((u_int) __eea-> eea_reserved_first) + i]), pte_flags), va, 0, NULL) < 0 || _exos_self_unmap_page(CAP_ROOT, (u_int)__eea->eea_reserved_first + i * NBPG) < 0) { sys_cputs("__remap_reserved_page: can't remap\n"); return -1; } UAREA.u_reserved_pages--; return 0; } } sys_cputs("__remap_reserved_page: none left\n"); return -1; }
int main(int argc, char** argv) { while(1); // try to print the kernel entry point as a string! mua ha ha! sys_cputs((char*)0xc0100020, 100); return 0; }
void __replinish(void) { u_int i; static int __in_replinishment = 0; if (__in_replinishment) return; if (UAREA.u_reserved_pages == __eea->eea_reserved_pages) return; __in_replinishment = 1; for (i=0; i < __eea->eea_reserved_pages; i++) { if (!(vpt[PGNO((u_int)__eea->eea_reserved_first) + i] & PG_P)) { if (_exos_self_insert_pte(CAP_ROOT, PG_P | PG_U | PG_W, (u_int)__eea->eea_reserved_first + i * NBPG, 0, NULL) < 0) { sys_cputs("__replinish: can't get new page\n"); } else { if (++UAREA.u_reserved_pages == __eea->eea_reserved_pages) break; } } } __in_replinishment = 0; }
void umain(int argc, char **argv) { int fd; char buf[512]; int n, r; cprintf("\n------------------------------------------------- Testing for 'File Write' replay by opening and reading it----------------\n"); //testCrash = 1; if ((fd = open("/testfile", O_RDWR )) < 0) panic("\n open /testfile failed: %e", fd); cprintf("\n------------------------------------------------- Testing for 'File Write' replay by opening and reading it----------------\n"); cprintf("\n-----------------------------------------------------The contents of the file being read are : ------------------------"); seek(fd, 0); while ((n = read(fd, buf, sizeof buf-1)) > 0) { cprintf("\n============================================================="); sys_cputs(buf, n); cprintf("=====================================================\n"); } cprintf("\n===\n"); close(fd); }
void umain(int argc, char **argv) { int fd, n, r; char buf[512+1]; binaryname = "icode"; cprintf("icode startup\n"); cprintf("icode: open /motd\n"); if ((fd = open("/motd", O_RDONLY)) < 0) panic("icode: open /motd: %e", fd); cprintf("icode: read /motd\n"); while ((n = read(fd, buf, sizeof buf-1)) > 0) sys_cputs(buf, n); cprintf("icode: close /motd\n"); close(fd); cprintf("icode: spawn /init\n"); if ((r = execl("/init", "init", "initarg1", "initarg2", (char*)0)) < 0) panic("icode: spawn /init: %e", r); panic("icode: unreachable code!\n"); }
// 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; }
void umain(int argc, char **argv) { int fd, n, r; char buf[512+1]; binaryname = "icode"; cprintf("icode startup\n"); cprintf("icode: open /motd\n"); if ((fd = open(MOTD, O_RDONLY)) < 0) panic("icode: open /motd: %e", fd); cprintf("icode: read /motd\n"); while ((n = read(fd, buf, sizeof buf-1)) > 0) { cprintf("Writing MOTD\n"); sys_cputs(buf, n); } cprintf("icode: close /motd\n"); close(fd); cprintf("icode: spawn /sbin/init\n"); if ((r = spawnl("/sbin/init", "init", "initarg1", "initarg2", (char*)0)) < 0) panic("icode: spawn /sbin/init: %e", r); cprintf("icode: exiting\n"); }
// 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. /*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. 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"); }
void umain(int argc, char **argv) { set_pgfault_handler(handler); // cprintf("%s\n",(char*) 0xDEADBEEF); // cprintf("-------------\n"); sys_cputs((char*)0xDEADBEEF, 4); }
static void putch(int ch, struct printbuf *b) { b->buf[b->idx++] = ch; if (b->idx == 256 - 1) { sys_cputs(b->buf, b->idx); b->idx = 0; } b->cnt++; }
static void putch(int ch, debugbuf_t **b) { (*b)->buf[(*b)->idx++] = ch; if ((*b)->idx == BUF_SIZE) { sys_cputs((*b)->buf, (*b)->idx); (*b)->idx = 0; } (*b)->cnt++; }
// 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 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"); }
void cputchar(int ch) { char c = ch; // Unlike standard Unix's putchar, // the cputchar function _always_ outputs to the system console. sys_cputs(&c, 1); }
void wrong(int rfd, int kfd, int off) { char buf[100]; int n; seek(rfd, off); seek(kfd, off); cprintf("shell produced incorrect output.\n"); cprintf("expected:\n===\n"); while ((n = read(kfd, buf, sizeof buf-1)) > 0) sys_cputs(buf, n); cprintf("===\ngot:\n===\n"); while ((n = read(rfd, buf, sizeof buf-1)) > 0) sys_cputs(buf, n); cprintf("===\n"); exit(); }
int vcprintf(const char *fmt, va_list ap) { struct printbuf b; b.idx = 0; b.cnt = 0; vprintfmt((void*) putch, &b, fmt, ap); sys_cputs(b.buf, b.idx); return b.cnt; }
// 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"); }
/* of stack and still be valid */ int page_fault_handler (u_int va, u_int errcode, u_int eflags, u_int eip, u_int esp) { u_int page = va & ~PGMASK; int ret; u_int oldxsp; if (UAREA.u_in_pfault > 5) { static int done_before = 0; if (!done_before) { sys_cputs("<< Recursive page fault to at least 6 levels. " "Continuing... >>\n"); done_before = 1; } } UAREA.u_in_pfault++; /* fault in the BSS */ if (va >= PGROUNDUP((u_int)&edata) && va < (u_int)&end && !(errcode & FEC_PR)) { if ((ret = _exos_self_insert_pte (0, PG_U|PG_W|PG_P, page, ESIP_URGENT, NULL)) < 0) { sys_cputs ("page_fault_handler(bss): _exos_self_insert_pte failed\n"); exit(-1); } bzero((char*)page, NBPG); goto leave; } /* copy-on-write fault */ if ((vpd[PDENO(va)] & (PG_P|PG_U)) == (PG_P|PG_U)) { Pte pte = vpt[va >> PGSHIFT]; if (((pte & (PG_COW | PG_P | PG_U)) == (PG_COW | PG_P | PG_U)) && (errcode & FEC_WR)) { do_cow_fault (va, pte, eip); goto leave; } }
int ros_vdebug(const char *fmt, va_list ap) { debugbuf_t b; debugbuf_t *COUNT(1) bp = &b; b.idx = 0; b.cnt = 0; ros_vdebugfmt((void*)putch, (void*)&bp, fmt, ap); sys_cputs(b.buf, b.idx); return b.cnt; }
// 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; } }
// 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 umain(int argc, char **argv) { int rfd, wfd; char buf[512]; int n, r; if ((rfd = open("/newmotd", O_RDONLY)) < 0) panic("open /newmotd: %e", rfd); if ((wfd = open("/motd", O_RDWR)) < 0) panic("open /motd: %e", wfd); cprintf("file descriptors %d %d\n", rfd, wfd); if (rfd == wfd) panic("open /newmotd and /motd give same file descriptor"); cprintf("OLD MOTD\n===\n"); while ((n = read(wfd, buf, sizeof buf-1)) > 0) sys_cputs(buf, n); cprintf("===\n"); seek(wfd, 0); if ((r = ftruncate(wfd, 0)) < 0) panic("truncate /motd: %e", r); cprintf("NEW MOTD\n===\n"); while ((n = read(rfd, buf, sizeof buf-1)) > 0) { sys_cputs(buf, n); if ((r = write(wfd, buf, n)) != n) panic("write /motd: %e", r); } cprintf("===\n"); if (n < 0) panic("read /newmotd: %e", n); close(rfd); close(wfd); }
// 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; } }
static ssize_t devcons_write(struct Fd *fd, const void *vbuf, size_t n) { size_t tot, m; char buf[128]; // mistake: have to nul-terminate arg to sys_cputs, // so we have to copy vbuf into buf in chunks and nul-terminate. for (tot = 0; tot < n; tot += m) { m = n - tot; if (m > sizeof(buf) - 1) m = sizeof(buf) - 1; memmove(buf, (char*)vbuf + tot, m); sys_cputs(buf, m); } return tot; }
// 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); } }
// `High'-level console I/O. Used by readline and cprintf. void cputs(const char *str) { if (read_cs() & 3) return sys_cputs(str); // use syscall from user mode // Hold the console spinlock while printing the entire string, // so that the output of different cputs calls won't get mixed. // Implement ad hoc recursive locking for debugging convenience. bool already = spinlock_holding(&cons_lock); if (!already) spinlock_acquire(&cons_lock); char ch; while (*str) cons_putc(*str++); if (!already) spinlock_release(&cons_lock); }