예제 #1
0
파일: fork.c 프로젝트: ren85/jos2006
//
// Custom page fault handler - if faulting page is copy-on-write,
// map in our own private writable copy.
//
static void
pgfault(struct UTrapframe *utf)
{
	void *addr = (void *) utf->utf_fault_va;
	uint32_t err = utf->utf_err;
	int r;
	pte_t pte;
	envid_t envid;
	void *va;

	// Check that the faulting access was (1) a write, and (2) to a
	// copy-on-write page.  If not, panic.
	// Hint:
	//   Use the read-only page table mappings at vpt
	//   (see <inc/memlayout.h>).

	// LAB 4: Your code here.

	//check # 1 - ren
	 if (!(err & FEC_WR))
		panic ("pgfault() - page fault caused not by write!");
	//check # 2 - ren
	pte = (pte_t)vpt[VPN(addr)];
	pte &= 0xF00;
	if (pte != PTE_COW)
		panic ("pgfault() - access was not to a copy-on-write page!");	
	
	// Allocate a new page, map it at a temporary location (PFTEMP),
	// copy the data from the old page to the new page, then move the new
	// page to the old page's address.
	// Hint:
	//   You should make three system calls.
	//   No need to explicitly delete the old page's mapping.
	
	// LAB 4: Your code here.
	
	envid = sys_getenvid();
	va = (void*)ROUNDDOWN(addr, PGSIZE);

	if ( (r = sys_page_alloc(envid, PFTEMP, PTE_U | PTE_P | PTE_W)) < 0)
		sys_env_destroy(envid);

	memcpy(PFTEMP, va, PGSIZE);

	if ( (r = sys_page_map(envid, PFTEMP, envid, va, PTE_U | PTE_P | PTE_W)) < 0)
		sys_env_destroy(envid);
	
	if ((r = sys_page_unmap(envid, PFTEMP)) < 0)		//fourth system call, hm - ren
		sys_env_destroy(envid);
}
예제 #2
0
파일: syscall.c 프로젝트: iprem/JOS
// 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;
}
예제 #3
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.
	/*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");
}
예제 #4
0
파일: spin.c 프로젝트: 1060351485/6.828-JOS
void
umain(int argc, char **argv)
{
	envid_t env;

	cprintf("I am the parent.  Forking the child...\n");
	if ((env = fork()) == 0) {
		cprintf("I am the child.  Spinning...\n");
		while (1)
			/* do nothing */;
	}

	cprintf("I am the parent.  Running the child...\n");
	sys_yield();
	sys_yield();
	sys_yield();
	sys_yield();
	sys_yield();
	sys_yield();
	sys_yield();
	sys_yield();

	cprintf("I am the parent.  Killing the child...\n");
	sys_env_destroy(env);
}
예제 #5
0
파일: testsfork.c 프로젝트: nollaG/jos
void
umain(int argc, char **argv)
{
  envid_t env;
	cprintf("Father:%04x", sys_getenvid());
  a=1;
  if ((env = sfork()) == 0) {
    while (1) {
      cprintf("child:a=%d\n",a);
      sys_yield();
    }
    exit();
  }
  sys_yield();
  sys_yield();
  sys_yield();
  sys_yield();
  sys_yield();
  sys_yield();
  cprintf("Father:a changed\n");
  a=2;
  sys_yield();
  sys_yield();
  sys_yield();
  sys_yield();
  sys_yield();
  sys_yield();
  cprintf("Killing the child\n");
  sys_env_destroy(env);
}
예제 #6
0
파일: pgfault.c 프로젝트: yahu/JOS
//
// Set the page fault handler function.
// If there isn't one yet, _pgfault_handler will be 0.
// The first time we register a handler, we need to
// allocate an exception stack (one page of memory with its top
// at UXSTACKTOP), and tell the kernel to call the assembly-language
// _pgfault_upcall routine when a page fault occurs.
//
void
set_pgfault_handler(void (*handler)(struct UTrapframe *utf))
{
	int r;
    int re;
    envid_t envid = sys_getenvid();

	if (_pgfault_handler == 0) {
		// First time through!
		// LAB 4: Your code here.

		sys_env_set_pgfault_upcall(envid, _pgfault_upcall);
		re = sys_page_alloc(envid, (void *)(UXSTACKTOP - PGSIZE),PTE_U | PTE_P |PTE_W);
        if( re < 0){
            cprintf("process %x,sys_page_alloc fail\n",envid);
            sys_env_destroy(envid);
        }

		//panic("set_pgfault_handler not implemented");
	}

	// Save handler pointer for assembly to call.

	_pgfault_handler = handler;
	//cprintf("_pgfault_handler = %x\n",(uint32_t)_pgfault_handler);
}
예제 #7
0
// Dispatches to the correct kernel function, passing the arguments.
int64_t
syscall(uint64_t syscallno, uint64_t a1, uint64_t a2, uint64_t a3, uint64_t a4, uint64_t a5)
{
	// Call the function corresponding to the 'syscallno' parameter.
	// Return any appropriate return value.
	// LAB 3: Your code here.
//	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;
	}
}
예제 #8
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.
    //
    // 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;
}
예제 #9
0
파일: syscall.c 프로젝트: ichaos/jos
// 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");
}
예제 #10
0
    void
handler(struct UTrapframe *utf)
{
    cprintf("\n IN FAULT DIE HANDLER \n");
    void *addr = (void*)utf->utf_fault_va;
    uint32_t err = utf->utf_err;
    cprintf("i faulted at va %x, err %x\n", addr, err & 7);
    sys_env_destroy(sys_getenvid());
}
예제 #11
0
파일: syscall.c 프로젝트: dannoy/JOS
// 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;
}
예제 #12
0
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
	// Call the function corresponding to the 'syscallno' parameter.
	// Return any appropriate return value.
	// LAB 3: Your code here.
	int32_t ret = -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");
}
예제 #13
0
파일: syscall.c 프로젝트: yaobaiwei/JOS
// 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");
}
예제 #14
0
파일: syscall.c 프로젝트: yuki252111/os
// 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;
	}
}
예제 #15
0
파일: syscall.c 프로젝트: Cai41/mit-6.828
// 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;
}
예제 #16
0
파일: syscall.c 프로젝트: ajsbu/cse506
// 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");
}
예제 #17
0
파일: syscall.c 프로젝트: bdmalab/6.828
// 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;
	}
}
예제 #18
0
파일: syscall.c 프로젝트: ren85/jos2006
// 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); 
	}
}
예제 #19
0
파일: syscall.c 프로젝트: reddragon/cse506
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
	// Call the function corresponding to the 'syscallno' parameter.
	// Return any appropriate return value.
	// LAB 3: Your code here.
	// My code: gmenghani
	// An invalid system call
	if(syscallno >= NSYSCALLS)
		return -E_INVAL;

	switch(syscallno) {
		case SYS_cputs: 	sys_cputs((char *) a1, (size_t)a2);
					return 0;
		case SYS_cgetc:		return sys_cgetc();
		case SYS_getenvid:	return sys_getenvid();
		case SYS_env_destroy:	return sys_env_destroy((envid_t)a1);
		case SYS_yield : sys_yield(); break;
		case SYS_exofork : return sys_exofork();
		case SYS_env_set_status : return sys_env_set_status((envid_t)a1, (int)a2);
		case SYS_page_alloc : return sys_page_alloc((envid_t)a1, (void*)a2, (int)a3);
		case SYS_page_map : return sys_page_map((envid_t)a1, (void*)a2, (envid_t)a3, (void*)a5, (int)a4);
		case SYS_page_unmap : return sys_page_unmap((envid_t)a1, (void*)a2);
		// For Challenge problem 1 Lab 4a
		case SYS_env_set_nice:	sys_env_set_nice(a1);
					return 0;
		case SYS_env_set_pgfault_upcall: sys_env_set_pgfault_upcall((envid_t)a1, (void *)a2);
		                                 return 0;
		case SYS_ipc_try_send: return sys_ipc_try_send((envid_t)a1, (uint32_t)a2, (void*)a3, (unsigned)a5);
		case SYS_ipc_recv: return sys_ipc_recv((void*)a1);
		case SYS_env_set_trapframe: return sys_env_set_trapframe((envid_t)a1, (struct Trapframe*)a2);
		case SYS_time_msec: return sys_time_msec();
		case SYS_net_send: return sys_net_send((void*)a1, (uint32_t) a2);
		case SYS_net_recv: return sys_net_recv((void*)a1, (uint16_t*) a2);
	}
	return 0;
}
예제 #20
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.

	//panic("syscall not implemented");

	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(curenv->env_id); 
		default:
			return -E_INVAL;
	}	
}
예제 #21
0
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
	// Call the function corresponding to the 'syscallno' parameter.
	// Return any appropriate return value.
	// LAB 3: Your code here.

  int32_t ret=0;
  /* if(syscallno==SYS_cputs||syscallno==SYS_getenvid||syscallno==SYS_env_destroy||syscallno==SYS_cgetc)
{
         if(syscallno==SYS_cputs)
               sys_cputs((char *)a1,a2);

                  if(syscallno==SYS_getenvid)
                        return sys_getenvid();

                  if(syscallno==SYS_env_destroy)
                        return sys_env_destroy(a1);

               if(syscallno==SYS_cgetc)
                     return sys_cgetc();
   return ret;
}*/
//cprintf("\nNO----%d\n",syscallno);
 switch (syscallno) {  
     case SYS_cputs:  
         sys_cputs((const char *)a1, (size_t)a2);  
         break;  
     case SYS_cgetc:  
         ret = sys_cgetc();  
         break;  
     case SYS_getenvid:  
         ret = sys_getenvid();  
         break;  
     case SYS_env_destroy:  
         ret = sys_env_destroy((envid_t)a1);  
         break;
    case SYS_yield:
           sys_yield();
       break;
    case SYS_exofork:
        ret=sys_exofork();
       break;
    case SYS_env_set_status:
         ret = sys_env_set_status(a1,a2);
        break;
    case SYS_page_alloc:
         ret = sys_page_alloc(a1,(void *)a2,a3);
        break;
    case SYS_page_map:
         ret = sys_page_map(a1,(void *)a2,a3,(void *)a4,a5);
        break;
    case SYS_page_unmap:
         ret = sys_page_unmap(a1,(void *)a2);
        break;
    case SYS_env_set_pgfault_upcall:
         ret = sys_env_set_pgfault_upcall(a1,(void *)a2);
    case SYS_ipc_try_send:
          ret=sys_ipc_try_send(a1,a2,(void *)a3,a4);
          break;
    case SYS_ipc_recv:
          ret=sys_ipc_recv((void *)a1);
           break;
   case SYS_env_set_trapframe:
         ret=sys_env_set_trapframe(a1,(struct Trapframe *)a2);
    break;
   case SYS_time_msec:
         ret=sys_time_msec();
    break;
   case SYS_call_packet_send:
         ret=sys_call_packet_send((void *)a1,a2);
   break;
   case SYS_call_receive_packet:
         ret=sys_call_receive_packet((void *)a1,(void *)a2);
       break;
     default:  
         // NSYSCALLS  
         ret = -E_INVAL;  
         break;  
    }
  return ret;
}
예제 #22
0
파일: syscall.c 프로젝트: rinascere/Jos
// 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.
	//cprintf("syscallno is %d\n",syscallno);
	switch (syscallno){
		case SYS_getenvid:
			//cprintf("in kernel SYS_getenvid!\n");
			return sys_getenvid();
		case SYS_cputs:
			//cprintf("in kernel SYS_cputs!\n");
			sys_cputs((const char*) a1,a2);
			return 0;
		case SYS_cgetc:
			//cprintf("in kernel SYS_cgetc!\n");
			return sys_cgetc();
		case SYS_env_destroy:
			//cprintf("in kernel SYS_env_destroy!\n");
			return sys_env_destroy(a1);
		case SYS_map_kernel_page:
			//cprintf("in kernel SYS_map_kernel_page!\n");
			return sys_map_kernel_page((void *)a1, (void *)a2);
		case SYS_yield:
			//cprintf("in kernel SYS_yield!\n");
			//unlock_kernel();
			sys_yield();
			return 0;
		case SYS_page_alloc:
			//cprintf("in kernel SYS_page_alloc!\n");
			//cprintf("in kern sys_page_alloc!\n");
			return sys_page_alloc((envid_t) a1, (void *) a2, (int) a3);
		case SYS_page_map:
			//cprintf("in kernel SYS_page_map!\n");
			//cprintf("in kern sys_page_map!\n");
			//cprintf("in kern get arglist is %p\n",a1);
			//cprintf("value of a1 is %p\n",*((uint32_t *)a1+1));
			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:
			//cprintf("in kernel SYS_page_unmap!\n");
			//cprintf("in kern sys_page_unmap!\n");
			return sys_page_unmap((envid_t) a1, (void *) a2);
		case SYS_exofork:
			//cprintf("in kernel SYS_exofork!\n");
			//cprintf("in kern sys_exofork!\n");
			return sys_exofork();
		case SYS_env_set_status:
			//cprintf("in kernel SYS_env_set_status!\n");
			//cprintf("in kern sys_env_set_status!\n");
			//cprintf("syscall in envid %p status %p\n",a1,a2);
			return sys_env_set_status((envid_t) a1, (int) a2);
		case SYS_env_set_pgfault_upcall:
			//cprintf("in kernel SYS_env_set_pgfault_upcall!\n");
			return sys_env_set_pgfault_upcall((envid_t) a1, (void *) a2);
		case SYS_ipc_recv:
			//cprintf("in syscall recive!\n");
			return sys_ipc_recv((void*)a1);
		case SYS_ipc_try_send:
			//cprintf("in syscall send!\n");
			return sys_ipc_try_send((envid_t)a1,a2,(void*)a3,(int)a4);
		case SYS_proc_save:
			return sys_proc_save((envid_t)a1,(struct proc *)a2);
		case SYS_proc_resume:
			return sys_proc_resume((envid_t)a1,(struct proc*)a2);
		default:
			return -E_INVAL;
	}

//	panic("syscall not implemented");
}
예제 #23
0
파일: spawn.c 프로젝트: reimeiyou/JOS-Log
// Spawn a child process from a program image loaded from the file system.
// prog: the pathname of the program to run.
// argv: pointer to null-terminated array of pointers to strings,
// 	 which will be passed to the child as its command-line arguments.
// Returns child envid on success, < 0 on failure.
int
spawn(const char *prog, const char **argv)
{
	unsigned char elf_buf[512];
	struct Trapframe child_tf;
	envid_t child;

	int fd, i, r;
	struct Elf *elf;
	struct Proghdr *ph;
	int perm;

	// This code follows this procedure:
	//
	//   - Open the program file.
	//
	//   - Read the ELF header, as you have before, and sanity check its
	//     magic number.  (Check out your load_icode!)
	//
	//   - Use sys_exofork() to create a new environment.
	//
	//   - Set child_tf to an initial struct Trapframe for the child.
	//
	//   - Call the init_stack() function above to set up
	//     the initial stack page for the child environment.
	//
	//   - Map all of the program's segments that are of p_type
	//     ELF_PROG_LOAD into the new environment's address space.
	//     Use the p_flags field in the Proghdr for each segment
	//     to determine how to map the segment:
	//
	//	* If the ELF flags do not include ELF_PROG_FLAG_WRITE,
	//	  then the segment contains text and read-only data.
	//	  Use read_map() to read the contents of this segment,
	//	  and map the pages it returns directly into the child
	//        so that multiple instances of the same program
	//	  will share the same copy of the program text.
	//        Be sure to map the program text read-only in the child.
	//        Read_map is like read but returns a pointer to the data in
	//        *blk rather than copying the data into another buffer.
	//
	//	* If the ELF segment flags DO include ELF_PROG_FLAG_WRITE,
	//	  then the segment contains read/write data and bss.
	//	  As with load_icode() in Lab 3, such an ELF segment
	//	  occupies p_memsz bytes in memory, but only the FIRST
	//	  p_filesz bytes of the segment are actually loaded
	//	  from the executable file - you must clear the rest to zero.
	//        For each page to be mapped for a read/write segment,
	//        allocate a page in the parent temporarily at UTEMP,
	//        read() the appropriate portion of the file into that page
	//	  and/or use memset() to zero non-loaded portions.
	//	  (You can avoid calling memset(), if you like, if
	//	  page_alloc() returns zeroed pages already.)
	//        Then insert the page mapping into the child.
	//        Look at init_stack() for inspiration.
	//        Be sure you understand why you can't use read_map() here.
	//
	//     Note: None of the segment addresses or lengths above
	//     are guaranteed to be page-aligned, so you must deal with
	//     these non-page-aligned values appropriately.
	//     The ELF linker does, however, guarantee that no two segments
	//     will overlap on the same page; and it guarantees that
	//     PGOFF(ph->p_offset) == PGOFF(ph->p_va).
	//
	//   - Call sys_env_set_trapframe(child, &child_tf) to set up the
	//     correct initial eip and esp values in the child.
	//
	//   - Start the child process running with sys_env_set_status().

	if ((r = open(prog, O_RDONLY)) < 0)
		return r;
	fd = r;

	// Read elf header
	elf = (struct Elf*) elf_buf;
	if (readn(fd, elf_buf, sizeof(elf_buf)) != sizeof(elf_buf)
	    || elf->e_magic != ELF_MAGIC) {
		close(fd);
		cprintf("elf magic %08x want %08x\n", elf->e_magic, ELF_MAGIC);
		return -E_NOT_EXEC;
	}

	// Create new child environment
	if ((r = sys_exofork()) < 0)
		return r;
	child = r;

	// Set up trap frame, including initial stack.
	child_tf = envs[ENVX(child)].env_tf;
	child_tf.tf_eip = elf->e_entry;

	if ((r = init_stack(child, argv, &child_tf.tf_esp)) < 0)
		return r;

	// Set up program segments as defined in ELF header.
	ph = (struct Proghdr*) (elf_buf + elf->e_phoff);
	for (i = 0; i < elf->e_phnum; i++, ph++) {
		if (ph->p_type != ELF_PROG_LOAD)
			continue;
		perm = PTE_P | PTE_U;
		if (ph->p_flags & ELF_PROG_FLAG_WRITE)
			perm |= PTE_W;
		if ((r = map_segment(child, ph->p_va, ph->p_memsz,
				     fd, ph->p_filesz, ph->p_offset, perm)) < 0)
			goto error;
	}
	close(fd);
	fd = -1;

	// Copy shared library state.
	if ((r = copy_shared_pages(child)) < 0)
		panic("copy_shared_pages: %e", r);

	if ((r = sys_env_set_trapframe(child, &child_tf)) < 0)
		panic("sys_env_set_trapframe: %e", r);

	if ((r = sys_env_set_status(child, ENV_RUNNABLE)) < 0)
		panic("sys_env_set_status: %e", r);

	return child;

error:
	sys_env_destroy(child);
	close(fd);
	return r;
}
예제 #24
0
파일: exit.c 프로젝트: EastL/6.828
void
exit(int retcode)
{
	close_all();
	sys_env_destroy(0, retcode);
}
예제 #25
0
파일: spawn.c 프로젝트: donguoxing/Lab3
// Spawn a child process from a program image.
// In Lab 4, the image is loaded from the kernel.
// In Lab 5, you will allow images to be loaded from the file system.
// prog: the name of the program to run.
// argv: pointer to null-terminated array of pointers to strings,
// 	 which will be passed to the child as its command-line arguments.
// Returns child envid on success, < 0 on failure.
envid_t
spawn(const char* progname, const char** argv)
{
	uint8_t elf_header_buf[512];
	ssize_t elf_size;
	struct Trapframe child_tf; 	/* Hint!! */

	// Insert your code, following approximately this procedure:
	//
	//   - Look up the program using sys_program_lookup.
	//     Return an error code if no such program exists.
	//
	envid_t child, envid;
	int pid, err;
	pid = sys_program_lookup(progname,sizeof(progname)); 
	if(pid < 0)
		return pid;
	//   - Set 'elf_size' to the program's ELF binary size using
	//     sys_program_size.
	//
	elf_size = sys_program_size(pid);
	//   - Map the program's first page at UTEMP using the map_page helper.
	//
	envid = sys_getenvid();
	map_page(envid, pid, 0, (void *)UTEMP, PTE_U|PTE_P);

	//   - Copy the 512-byte ELF header from UTEMP into elf_header_buf.
	//
	memcpy(elf_header_buf, (void *)UTEMP, 512);
	//   - Read the ELF header, as you have before, and sanity check its
	//     magic number.  (Check out your load_elf for hints!)
	//
	struct Elf *elfbin = (struct Elf *)elf_header_buf;
    if (elfbin->e_magic != ELF_MAGIC)
    	return -E_INVAL;
	//   - Use sys_exofork() to create a new environment.
	//
	child = sys_exofork();
	if (child < 0)
		panic("sys_exofork: %e", child);
	if (child == 0) {
		return 0;
	}

	//   - Set child_tf to an initial struct Trapframe for the child.
	//     Hint: The sys_exofork() system call has already created
	//     a good starting point.  It is accessible at
	//     envs[ENVX(child)].env_tf.
	//     Hint: You must do something with the program's entry point.
	//     What?  (See load_elf!)
	//
	child_tf = envs[ENVX(child)].env_tf;
	//child_tf.tf_regs = envs[ENVX(child)].env_tf.tf_regs;
	child_tf.tf_eip = elfbin->e_entry;
	//sys_env_set_trapframe(child, &child_tf);
	
	//   - Call the init_stack() function to set up the initial stack
	//     page for the child environment.
	//
	if((err = init_stack(child,argv,&(child_tf.tf_esp))) < 0){
	sys_env_destroy(child);
	return err;
	}
	//   - Map all of the program's segments that are of p_type
	//     ELF_PROG_LOAD into the new environment's address space.
	//     Use the load_segment() helper function below.
	//     All the 'struct Proghdr' structures will be accessible
	//     within the first 512 bytes of the ELF.
	//
	// load each program segment (ignores ph flags)
	struct Proghdr *ph, *eph;
    ph = (struct Proghdr *) ((uint8_t *) elfbin + elfbin->e_phoff);
	eph = ph + elfbin->e_phnum;
	for(; ph < eph; ph++){
		if(ph->p_type != ELF_PROG_LOAD){
			continue;
		}
		assert(ph->p_filesz <= ph->p_memsz);
		load_segment(child, pid, ph, elfbin, elf_size);
	}
	//   - Call sys_env_set_trapframe(child, &child_tf) to set up the
	//     correct initial eip and esp values in the child.
	//
	if((err = sys_env_set_trapframe(child, &child_tf)) < 0){
		sys_env_destroy(child);
		return err;
	}
	//   - Start the child process running with sys_env_set_status().
	///
	if((err = sys_env_set_status(child,ENV_RUNNABLE)) < 0){
		sys_env_destroy(child);
		return err;
	}
	//panic("spawn unimplemented!");
	return 0;
}
예제 #26
0
파일: syscall.c 프로젝트: gzs715/JOS
// 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.
	uint32_t result = -E_INVAL;
	//cprintf("syscallno:%08x\n",syscallno);
	switch(syscallno)
	{
		case SYS_cputs:
			sys_cputs((char *)a1,(size_t)a2);
			result = SYS_cputs;
			break;
		case SYS_getenvid:
			result = sys_getenvid();
			break;
		case SYS_cgetc:
			result = sys_cgetc();
			break;
		case SYS_env_destroy:
			result = sys_env_destroy((envid_t)a1);
			break;
		case SYS_env_set_trapframe:
			result = sys_env_set_trapframe((envid_t)a1, (struct Trapframe *)a2);
			break;
		case SYS_yield:
			sys_yield();
			result = SYS_yield;
			break;
		case SYS_exofork:
			result = sys_exofork();
			break;
		case SYS_env_set_status:
			result = sys_env_set_status((envid_t)a1,(int)a2);
			break;
		case SYS_page_alloc:
			result = sys_page_alloc((envid_t)a1,(void *)a2,(int)a3);
			break;
		case SYS_page_map:
			result = sys_page_map((envid_t)a1,(void *)a2,(envid_t)a3,(void *)a4,(int)a5);
			break;
		case SYS_page_unmap:
			result = sys_page_unmap((envid_t)a1,(void *)a2);
			break;	
		case SYS_env_set_pgfault_upcall:
			result = sys_env_set_pgfault_upcall((envid_t)a1,(void*)a2);
			break;	
		case SYS_ipc_recv:
			result = sys_ipc_recv((void*)a1);
			break;
		case SYS_ipc_try_send:
			result = sys_ipc_try_send((envid_t)a1, (uint32_t)a2, (void *)a3, (unsigned)a4);
			break;
		case SYS_for_fork:
			result = sys_for_fork((envid_t)a1, (void *)a2, (int)a3);
			break;
		case SYS_set_shforkid:
			result = sys_set_shforkid((envid_t)a1);
			break;	
			
		default:
			result = -E_INVAL;
	}
	return result;
}
예제 #27
0
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
	// Call the function corresponding to the 'syscallno' parameter.
	// Return any appropriate return value.
	// LAB 3: Your code here.
    int32_t res;
    a5 = syscallno >> 8;
    syscallno -= (a5<<8);
    //if(a5!=0)cprintf("syscallno %d %x %x\n",syscallno,a1,a5);
    switch(syscallno)
    {
        case SYS_cputs:
            sys_cputs((const char*)a1,(size_t)a2);
            res = 0;
            break;
        case SYS_cgetc:
            res = sys_cgetc();
            break;
        case SYS_getenvid:
            res = sys_getenvid();
            break;
        case SYS_env_destroy:
            res = sys_env_destroy(a1);
            break;
        case SYS_map_kernel_page:
            res = sys_map_kernel_page((void*)a1,(void*)a2);
            break;
        case SYS_yield:
            res = 0;
            sys_yield();
            break;
        case SYS_exofork:
            res = sys_exofork();
            break;
        case SYS_env_set_status:
            res = sys_env_set_status(a1,a2);
            break;
        case SYS_page_alloc:
            res = sys_page_alloc(a1,(void*)a2,a3);
            break;
        case SYS_page_map:
            res = sys_page_map(a1,(void*)a2,a3,(void*)a4,(int)a5);
            break;
        case SYS_page_unmap:
            res = sys_page_unmap(a1,(void*)a2);
            break;
        case SYS_env_set_pgfault_upcall:
            res = sys_env_set_pgfault_upcall(a1,(void*)a2);
            break;
        case SYS_ipc_try_send:
            res = sys_ipc_try_send(a1,a2,(void*)a3,a4);
            break;
        case SYS_ipc_recv:
            res = sys_ipc_recv((void*)a1);
            break;
        case NSYSCALLS:
        default:
            res = -E_INVAL;
    }
    //cprintf("res %x\n",res);
    return res;
}
예제 #28
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.
	/*stone's solution for lab3-B*/
	int32_t ret = -E_INVAL;
	switch (syscallno){
		case SYS_cputs:
			sys_cputs((char*)a1, a2);
			ret = 0;
			break;
		case SYS_cgetc:
			ret = sys_cgetc();
			break;
		case SYS_getenvid:
			ret = sys_getenvid();
			break;
		case SYS_env_destroy:
			ret = sys_env_destroy(a1);
			break;
		case SYS_map_kernel_page:
			ret = sys_map_kernel_page((void*)a1, (void*)a2);
			break;
		case SYS_sbrk:
			ret = sys_sbrk(a1);
			break;
		/*stone's solution for lab4-A*/
		case SYS_yield:
			sys_yield();
			ret = 0;
			break;
		case SYS_exofork:
			ret = sys_exofork();
			break;
		case SYS_env_set_status:
			ret = sys_env_set_status(a1, a2);
			break;
		case SYS_env_set_pgfault_upcall:
			ret = sys_env_set_pgfault_upcall((envid_t)a1, (void*)a2);
			break;
		case SYS_page_alloc:
			ret = sys_page_alloc((envid_t)a1, (void*)a2, (int)a3);
			break;
		case SYS_page_map:
			/*stone: see lib/syscall.c for modification details*/
			ret = sys_page_map(*((uint32_t*)a1), (void*)*((uint32_t*)a1 + 1), *((uint32_t*)a1 + 2), (void*)*((uint32_t*)a1 + 3), *((uint32_t*)a1 + 4));
			//ret = sys_page_map(a1, (void*)a2, a3, (void*)a4, a5);
			break;
		case SYS_page_unmap:
			ret = sys_page_unmap(a1, (void*)a2);
			break;
		case SYS_ipc_recv:
			ret = sys_ipc_recv((void*)a1);
			break;
		case SYS_ipc_try_send:
			ret = sys_ipc_try_send((envid_t)a1, a2, (void*)a3, (int)a4);
			break;
		case SYS_env_set_trapframe:
			ret = sys_env_set_trapframe((envid_t)a1, (struct Trapframe*)a2);
			break;
		default:
			break;
	}
	return ret;
	//panic("syscall not implemented");
}
예제 #29
0
파일: syscall.c 프로젝트: ChenLanbo/OS-Lab
// Dispatches to the correct kernel function, passing the arguments.
int32_t
syscall(uint32_t syscallno, uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4, uint32_t a5)
{
	// Call the function corresponding to the 'syscallno' parameter.
	// Return any appropriate return value.
	switch(syscallno){
		case SYS_cputs:
			user_mem_assert(curenv, (void *)a1, a2, PTE_U);
			sys_cputs((char *)a1, a2);
			return 0;
			break;
		case SYS_cgetc:
			return sys_cgetc();
			break;
		case SYS_getenvid:
			return sys_getenvid();
			break;
		case SYS_getenv_parent_id:
			return sys_getenv_parent_id(a1);
			break;
		case SYS_env_destroy:
			return sys_env_destroy(a1);
			break;
		case SYS_page_alloc:
			return sys_page_alloc(a1, (void *)a2, a3);
			break;
		case SYS_page_map:
			return sys_page_map(a1, (void *)a2, a3, (void *)a4, a5);
			break;
		case SYS_page_unmap:
			return sys_page_unmap(a1, (void *)a2);
			break;
		case SYS_exofork:
			return sys_exofork();
			break;
		case SYS_env_set_status:
			return sys_env_set_status(a1, a2);
			break;
		case SYS_env_set_trapframe:
			return sys_env_set_trapframe(a1, (struct Trapframe *)a2);
			break;
		case SYS_env_set_pgfault_upcall:
			return sys_env_set_pgfault_upcall(a1, (void *)a2);
			break;
		case SYS_env_get_curdir:
			return sys_env_get_curdir((envid_t)a1, (char *)a2);
			break;
		case SYS_env_set_curdir:
			return sys_env_set_curdir((envid_t)a1, (char *)a2);
			break;
		case SYS_yield:
			sys_yield();
			break;
		case SYS_ipc_try_send:
			return sys_ipc_try_send(a1, a2, (void *)a3, a4);
			break;
		case SYS_ipc_recv:
			return sys_ipc_recv((void *)a1);
			break;
		case SYS_time_msec:
			return sys_time_msec();
			break;
		case SYS_net_send:
			return sys_net_send((void *)a1, a2);
			break;
		case SYS_net_recv:
			return sys_net_recv((void *)a1, a2);
			break;
		case NSYSCALLS:
		default:
			return -E_INVAL;
			break;
	}
	return 0;
}
예제 #30
0
파일: exit.c 프로젝트: 1060351485/6.828-JOS
void
exit(void)
{
	sys_env_destroy(0);
}