syscall.c

来自「ppc750 system design simulator using sys」· C语言 代码 · 共 1,548 行 · 第 1/4 页

	if(emulate_syscall)
		do_syscall();
}

char *sc_bin2c(ppc_inst_t inst, addr_t pc, char *buf)
{
	buf += sprintf(buf, "\tdo_syscall();\n");
	return buf;
}

char *sc_disasm(ppc_inst_t inst, addr_t pc, char *buf) { buf += sprintf(buf, "sc"); return buf; }

void sc_translate(ppc_inst_t inst, struct DecodedInstruction *di)
{
	di->iclass = ICSystemCall;
	di->operation.systemRegister.ident = ID_SC;
	di->hasImmed = FALSE;
}

void sc_xml(ppc_inst_t inst, addr_t pc, char *buf) { xmlf(buf, pc, "sc", 0); }

#undef READ_GPR
#undef WRITE_GPR
#undef RESET_CR0SO
#undef SET_CR0SO
#undef MEM_READ_BYTE
#undef MEM_WRITE_BYTE
#undef MEM_READ_HALF_WORD
#undef MEM_WRITE_HALF_WORD
#undef MEM_READ_WORD
#undef MEM_WRITE_WORD
#undef MEM_READ_DWORD
#undef MEM_WRITE_DWORD
#undef MEM_SET
#undef MEM_READ
#undef MEM_WRITE

#define READ_GPR(n) cb->read_gpr(cb->instance, n)
#define WRITE_GPR(n, v) cb->write_gpr(cb->instance, n, v)
#define RESET_CR0SO cb->reset_cr0so(cb->instance)
#define SET_CR0SO cb->set_cr0so(cb->instance)
#define MEM_READ_BYTE(addr) cb->mem_read_byte(cb->instance, addr)
#define MEM_WRITE_BYTE(addr, value) cb->mem_write_byte(cb->instance, addr, value)
#define MEM_READ_HALF_WORD(addr) cb->mem_read_half_word(cb->instance, addr)
#define MEM_WRITE_HALF_WORD(addr, value) cb->mem_write_half_word(cb->instance, addr, value)
#define MEM_READ_WORD(addr) cb->mem_read_word(cb->instance, addr)
#define MEM_WRITE_WORD(addr, value) cb->mem_write_word(cb->instance, addr, value)
#define MEM_READ_DWORD(addr) cb->mem_read_dword(cb->instance, addr)
#define MEM_WRITE_DWORD(addr, value) cb->mem_write_dword(cb->instance, addr, value)
#define MEM_SET(addr, value, size) cb->mem_set(cb->instance, addr, value, size)
#define MEM_READ(buf, addr, size) cb->mem_read(cb->instance, buf, addr, size)
#define MEM_WRITE(addr, buf, size) cb->mem_write(cb->instance, addr, buf, size)
#define STRLEN(addr) my_strlen(cb, addr)

#define PARM(i) READ_GPR(3+(i))
#define RETURN(x) WRITE_GPR(3, (x))
#define SYSCALL_NUM READ_GPR(0)

static void ppc_swap(void *buf, int count)
{
	if(count > 0)
	{
		char temp[8];
		char *src = (char *) buf + count - 1;
		char *dst = temp;
		
		do
		{
			*dst = *src;
		} while(src--, dst++, --count);
	}
}

static int my_strlen(syscall_cb_t *cb, addr_t addr)
{
	int len = 0;
	char buffer[32];
	
	while(1)
	{
		int size = sizeof(buffer);
		char *p = buffer;
		MEM_READ(buffer, addr, size);
		while(size > 0)
		{
			if(*p == 0) return len;
			len++;
			size--;
			p++;
		}
		addr += sizeof(buffer);
	}
}

BOOL ppc_syscall_exit(syscall_cb_t *cb)
{
	int ret = PARM(0);
	if(verbose)
		fprintf(stderr, "exit(%d)\n", ret);
	if(debuging)
	{
		debuging = FALSE;
	}
	else
	{
		if(running)
			running = FALSE;
		else
			exit_proc(ret);
	}
	return TRUE;
}

BOOL ppc_syscall_fork(syscall_cb_t *cb) { RETURN(-1); return FALSE; }

BOOL ppc_syscall_read(syscall_cb_t *cb)
{
	int fd;
	size_t count;
	addr_t buf_addr;
	void *buf;
	size_t ret;
	
	fd = PARM(0);
	buf_addr = PARM(1);
	count = (size_t) PARM(2);
	buf = malloc(count);
	if(verbose)
		fprintf(stderr, "read(fd=%d, buf=0x%08x, count=%d)\n", fd, buf_addr, count);
		
	if(buf)
	{
		ret = read(fd, buf, count);
		if(ret > 0) MEM_WRITE(buf_addr, buf, ret);
		free(buf);
	}
	else
	{
		ret = -1;
	}
	RETURN(ret);
	return ret != (size_t) -1;
}

BOOL ppc_syscall_write(syscall_cb_t *cb)
{
	int fd;
	size_t count;
	void *buf;
	addr_t buf_addr;
	size_t ret;
	
	fd = PARM(0);
	buf_addr = PARM(1);
	count = (size_t) PARM(2);
	if(verbose)
		fprintf(stderr, "write(fd=%d, buf=0x%08x, count=%d)\n", fd, buf_addr, count);
	buf = malloc(count);
	if(buf)
	{
		MEM_READ(buf, buf_addr, count);
		ret = write(fd, buf, count);
		free(buf);
	}
	else
	{
		ret = -1;
	}
	RETURN(ret);
	return ret != (size_t) -1;
}

BOOL ppc_syscall_open(syscall_cb_t *cb)
{
	addr_t addr;
	int pathnamelen;
	char *pathname;
	int flags;
	mode_t mode;
	int ret;
	
	addr = PARM(0);
	pathnamelen = STRLEN(addr);
	pathname = (char *) malloc(pathnamelen + 1);
	MEM_READ(pathname, addr, pathnamelen + 1);
	flags = PARM(1);
	mode = PARM(2);
	if(verbose)
		fprintf(stderr, "open(pathname=\"%s\", flags=%d, mode=%d)\n", pathname, flags, mode);
	ret = open(pathname, flags, mode);
	free(pathname);
	RETURN(ret);
	return ret != -1;
}
BOOL ppc_syscall_close(syscall_cb_t *cb)
{
	int fd;
	int ret;
	
	fd = PARM(0);
	if(verbose)
		fprintf(stderr, "close(fd=%d)\n", fd);
	ret = close(fd);
	RETURN(ret);
	return ret != -1;
}

BOOL ppc_syscall_waitpid(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_creat(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_link(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_unlink(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_execve(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_chdir(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_time(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_mknod(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_chmod(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_lchown(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_break(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_oldstat(syscall_cb_t *cb) { RETURN(-1); return FALSE; }

BOOL ppc_syscall_lseek(syscall_cb_t *cb)
{
	int fildes;
	off_t offset;
	int whence;
	off_t ret;
	
	fildes = PARM(0);
	offset = PARM(1);
	whence = PARM(2);
	if(verbose)
		fprintf(stderr, "lseek(fd=%d, offset=%lu, whence=%d)\n", fildes, offset, whence);
	ret = lseek(fildes, offset, whence);
	RETURN(ret);
	return ret != -1;
}

BOOL ppc_syscall_getpid(syscall_cb_t *cb)
{
	pid_t pid;
	
	if(verbose)
		fprintf(stderr, "getpid()\n");
	pid = getpid();
	RETURN(pid);
	return TRUE;
}

BOOL ppc_syscall_mount(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_umount(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_setuid(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_getuid(syscall_cb_t *cb)
{
	uid_t uid;
	
	if(verbose)
		fprintf(stderr, "getuid()\n");
	uid = getuid();
	RETURN(uid);
	return TRUE;
}

BOOL ppc_syscall_stime(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_ptrace(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_alarm(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_oldfstat(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_pause(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_utime(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_stty(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_gtty(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_access(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_nice(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_ftime(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_sync(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_kill(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_rename(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_mkdir(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_rmdir(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_dup(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_pipe(syscall_cb_t *cb) { RETURN(-1); return FALSE; }

static void ppc_swap_tms(struct tms *buf)
{
	ppc_swap(&buf->tms_utime, sizeof(&buf->tms_utime));
	ppc_swap(&buf->tms_stime, sizeof(&buf->tms_stime));
	ppc_swap(&buf->tms_cutime, sizeof(&buf->tms_cutime));
	ppc_swap(&buf->tms_cstime, sizeof(&buf->tms_cstime));
}

BOOL ppc_syscall_times(syscall_cb_t *cb)
{
	addr_t buf_addr;
	struct tms buf;
	clock_t ret;
	
	ret = times(&buf);	
	if(swap) ppc_swap_tms(&buf);
	buf_addr = PARM(0);
	MEM_WRITE(buf_addr, &buf, sizeof(struct tms));
	RETURN(ret);
	return ret != (clock_t) -1;
}

BOOL ppc_syscall_prof(syscall_cb_t *cb) { RETURN(-1); return FALSE; }

BOOL ppc_syscall_brk(syscall_cb_t *cb)
{
	word_t new_brk_point;
	BOOL success;
	
	new_brk_point = PARM(0);
	success = TRUE;//FALSE;
	if(verbose)
		fprintf(stderr, "brk(end=0x%08x)\n", new_brk_point);
	if(new_brk_point > brk_point)
	{
		brk_point = new_brk_point;
		success = TRUE;
	}
	
	RETURN(brk_point);
	return success;
}

BOOL ppc_syscall_setgid(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_getgid(syscall_cb_t *cb)
{
	gid_t gid;
	if(verbose)
		fprintf(stderr, "getgid()\n");
	gid = getgid();
	RETURN(gid);
	return TRUE;
}

BOOL ppc_syscall_signal(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_geteuid(syscall_cb_t *cb)
{
	uid_t uid;
	
	if(verbose)
		fprintf(stderr, "geteuid()\n");
	uid = geteuid();
	RETURN(uid);
	return TRUE;
}

BOOL ppc_syscall_getegid(syscall_cb_t *cb)
{
	gid_t gid;
	
	if(verbose)
		fprintf(stderr, "getegid()\n");
	gid = getegid();
	RETURN(gid);
	return TRUE;
}

BOOL ppc_syscall_acct(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_umount2(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_lock(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_ioctl(syscall_cb_t *cb) { 	RETURN(-1); return FALSE; }
BOOL ppc_syscall_fcntl(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_mpx(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_setpgid(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_ulimit(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_oldolduname(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_umask(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_chroot(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_ustat(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_dup2(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_getppid(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_getpgrp(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_setsid(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_sigaction(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_sgetmask(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_ssetmask(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_setreuid(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_setregid(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_sigsuspend(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_sigpending(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_sethostname(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_setrlimit(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_getrlimit(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_getrusage(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_gettimeofday(syscall_cb_t *cb) { RETURN(-1); return FALSE; }
BOOL ppc_syscall_settimeofday(syscall_cb_t *cb) { RETURN(-1); return FALSE; }