自学教程：C++ sys_cputs函数代码示例

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

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

voidumain(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_tsyscall(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;}

voidumain(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_tsyscall(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_tsyscall(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_tsyscall(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_tsyscall(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");}

voidumain(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_tsyscall(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_tsyscall(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");}

voidcputchar(int ch){	char c = ch;	// Unlike standard Unix's putchar,	// the cputchar function _always_ outputs to the system console.	sys_cputs(&c, 1);}

voidwrong(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_tsyscall(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  */intpage_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_tsyscall(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_tsyscall(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_tsyscall(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");}

    voidumain(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_tsyscall(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_tdevcons_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_tsyscall(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.voidcputs(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);}