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