syscall.c

RISC处理器仿真分析程序。可以用于研究通用RISC处理器的指令和架构设计。在linux下编译

	else
	  {
	    /* got an error, return details */
	    regs_R[2] = errno;
	    regs_R[7] = 1;
	  }
      }
      break;

    case SS_SYS_brk:
      {
	SS_ADDR_TYPE addr;

	/* round the new heap pointer to the its page boundary */
	addr = ROUND_UP(/*base*/regs_R[4], SS_PAGE_SIZE);

	/* check whether heap area has merged with stack area */
	if (addr >= mem_brk_point && addr < (unsigned int)regs_R[29])
	  {
	    regs_R[2] = 0;
	    regs_R[7] = 0;
	    mem_brk_point = addr;
	  }
	else
	  {
	    /* out of address space, indicate error */
	    regs_R[2] = ENOMEM;
	    regs_R[7] = 1;
	  }
      }
      break;

    case SS_SYS_lseek:
      /* seek into file */
      regs_R[2] = lseek(/*fd*/regs_R[4], /*off*/regs_R[5], /*dir*/regs_R[6]);

      /* check for an error condition */
      if (regs_R[2] != -1)
	regs_R[7] = 0;
      else
	{
	  /* got an error, return details */
	  regs_R[2] = errno;
	  regs_R[7] = 1;
	}
      break;

    case SS_SYS_getpid:
      /* get the simulator process id */
      /*result*/regs_R[2] = getpid();

      /* check for an error condition */
      if (regs_R[2] != -1)
	regs_R[7] = 0;
      else
	{
	  /* got an error, return details */
	  regs_R[2] = errno;
	  regs_R[7] = 1;
	}
      break;

    case SS_SYS_getuid:
      /* get current user id */
      /*first result*/regs_R[2] = getuid();

      /* get effective user id */
      /*second result*/regs_R[3] = geteuid();

      /* check for an error condition */
      if (regs_R[2] != -1)
	regs_R[7] = 0;
      else
	{
	  /* got an error, return details */
	  regs_R[2] = errno;
	  regs_R[7] = 1;
	}
      break;

    case SS_SYS_access:
      {
	char buf[MAXBUFSIZE];

	/* copy filename to host memory */
	mem_strcpy(mem_fn, Read, /*fName*/regs_R[4], buf);

	/* check access on the file */
	/*result*/regs_R[2] = access(buf, /*mode*/regs_R[5]);

	/* check for an error condition */
	if (regs_R[2] != -1)
	  regs_R[7] = 0;
	else
	  {
	    /* got an error, return details */
	    regs_R[2] = errno;
	    regs_R[7] = 1;
	  }
      }
      break;

    case SS_SYS_stat:
    case SS_SYS_lstat:
      {
	char buf[MAXBUFSIZE];
	struct ss_statbuf ss_sbuf;
	struct stat sbuf;

	/* copy filename to host memory */
	mem_strcpy(mem_fn, Read, /*fName*/regs_R[4], buf);

	/* stat() the file */
	if (syscode == SS_SYS_stat)
	  /*result*/regs_R[2] = stat(buf, &sbuf);
	else /* syscode == SS_SYS_lstat */
	  /*result*/regs_R[2] = lstat(buf, &sbuf);

	/* check for an error condition */
	if (regs_R[2] != -1)
	  regs_R[7] = 0;
	else
	  {
	    /* got an error, return details */
	    regs_R[2] = errno;
	    regs_R[7] = 1;
	  }

	/* translate from host stat structure to target format */
	ss_sbuf.ss_st_dev = SWAP_HALF(sbuf.st_dev);
	ss_sbuf.ss_st_ino = SWAP_WORD(sbuf.st_ino);
	ss_sbuf.ss_st_mode = SWAP_HALF(sbuf.st_mode);
	ss_sbuf.ss_st_nlink = SWAP_HALF(sbuf.st_nlink);
	ss_sbuf.ss_st_uid = SWAP_HALF(sbuf.st_uid);
	ss_sbuf.ss_st_gid = SWAP_HALF(sbuf.st_gid);
	ss_sbuf.ss_st_rdev = SWAP_HALF(sbuf.st_rdev);
	ss_sbuf.ss_st_size = SWAP_WORD(sbuf.st_size);
	ss_sbuf.ss_st_atime = SWAP_WORD(sbuf.st_atime);
	ss_sbuf.ss_st_mtime = SWAP_WORD(sbuf.st_mtime);
	ss_sbuf.ss_st_ctime = SWAP_WORD(sbuf.st_ctime);
	ss_sbuf.ss_st_blksize = SWAP_WORD(sbuf.st_blksize);
	ss_sbuf.ss_st_blocks = SWAP_WORD(sbuf.st_blocks);

	/* copy stat() results to simulator memory */
	mem_bcopy(mem_fn, Write, /*sbuf*/regs_R[5],
		  &ss_sbuf, sizeof(struct ss_statbuf));
      }
      break;

    case SS_SYS_dup:
      /* dup() the file descriptor */
      /*fd*/regs_R[2] = dup(/*fd*/regs_R[4]);

      /* check for an error condition */
      if (regs_R[2] != -1)
	regs_R[7] = 0;
      else
	{
	  /* got an error, return details */
	  regs_R[2] = errno;
	  regs_R[7] = 1;
	}
      break;

    case SS_SYS_pipe:
      {
	int fd[2];

	/* copy pipe descriptors to host memory */;
	mem_bcopy(mem_fn, Read, /*fd's*/regs_R[4], fd, sizeof(fd));

	/* create a pipe */
	/*result*/regs_R[7] = pipe(fd);

	/* copy descriptor results to result registers */
	/*pipe1*/regs_R[2] = fd[0];
	/*pipe 2*/regs_R[3] = fd[1];

	/* check for an error condition */
	if (regs_R[7] == -1)
	  {
	    regs_R[2] = errno;
	    regs_R[7] = 1;
	  }
      }
      break;

    case SS_SYS_getgid:
      /* get current group id */
      /*first result*/regs_R[2] = getgid();

      /* get current effective group id */
      /*second result*/regs_R[3] = getegid();

	/* check for an error condition */
      if (regs_R[2] != -1)
	regs_R[7] = 0;
      else
	{
	  /* got an error, return details */
	  regs_R[2] = errno;
	  regs_R[7] = 1;
	}
      break;

    case SS_SYS_ioctl:
      {
	char buf[NUM_IOCTL_BYTES];
	int local_req = 0;

	/* convert target ioctl() request to host ioctl() request values */
	switch (/*req*/regs_R[5]) {
/* #if !defined(__CYGWIN32__) */
	case SS_IOCTL_TIOCGETP:
	  local_req = TIOCGETP;
	  break;
	case SS_IOCTL_TIOCSETP:
	  local_req = TIOCSETP;
	  break;
	case SS_IOCTL_TCGETP:
	  local_req = TIOCGETP;
	  break;
/* #endif */
#ifdef TCGETA
	case SS_IOCTL_TCGETA:
	  local_req = TCGETA;
	  break;
#endif
#ifdef TIOCGLTC
	case SS_IOCTL_TIOCGLTC:
	  local_req = TIOCGLTC;
	  break;
#endif
#ifdef TIOCSLTC
	case SS_IOCTL_TIOCSLTC:
	  local_req = TIOCSLTC;
	  break;
#endif
	case SS_IOCTL_TIOCGWINSZ:
	  local_req = TIOCGWINSZ;
	  break;
#ifdef TCSETAW
	case SS_IOCTL_TCSETAW:
	  local_req = TCSETAW;
	  break;
#endif
#ifdef TIOCGETC
	case SS_IOCTL_TIOCGETC:
	  local_req = TIOCGETC;
	  break;
#endif
#ifdef TIOCSETC
	case SS_IOCTL_TIOCSETC:
	  local_req = TIOCSETC;
	  break;
#endif
#ifdef TIOCLBIC
	case SS_IOCTL_TIOCLBIC:
	  local_req = TIOCLBIC;
	  break;
#endif
#ifdef TIOCLBIS
	case SS_IOCTL_TIOCLBIS:
	  local_req = TIOCLBIS;
	  break;
#endif
#ifdef TIOCLGET
	case SS_IOCTL_TIOCLGET:
	  local_req = TIOCLGET;
	  break;
#endif
#ifdef TIOCLSET
	case SS_IOCTL_TIOCLSET:
	  local_req = TIOCLSET;
	  break;
#endif
	}

	if (!local_req)
	  {
	    /* FIXME: could not translate the ioctl() request, just warn user
	       and ignore the request */
	    warn("syscall: ioctl: ioctl code not supported d=%d, req=%d",
		 regs_R[4], regs_R[5]);
	    regs_R[2] = 0;
	    regs_R[7] = 0;
	  }
	else
	  {
	    /* ioctl() code was successfully translated to a host code */

	    /* if arg ptr exists, copy NUM_IOCTL_BYTES bytes to host mem */
	    if (/*argp*/regs_R[6] != 0)
	      mem_bcopy(mem_fn, Read, /*argp*/regs_R[6], buf, NUM_IOCTL_BYTES);

	    /* perform the ioctl() call */
	    /*result*/regs_R[2] = ioctl(/*fd*/regs_R[4], local_req, buf);

	    /* if arg ptr exists, copy NUM_IOCTL_BYTES bytes from host mem */
	    if (/*argp*/regs_R[6] != 0)
	      mem_bcopy(mem_fn, Write, regs_R[6], buf, NUM_IOCTL_BYTES);

	    /* check for an error condition */
	    if (regs_R[2] != -1)
	      regs_R[7] = 0;
	    else
	      {	
		/* got an error, return details */
		regs_R[2] = errno;
		regs_R[7] = 1;
	      }
	  }
      }
      break;

    case SS_SYS_fstat:
      {
	struct ss_statbuf ss_sbuf;
	struct stat sbuf;

	/* fstat() the file */
	/*result*/regs_R[2] = fstat(/*fd*/regs_R[4], &sbuf);

	/* check for an error condition */
	if (regs_R[2] != -1)
	  regs_R[7] = 0;
	else
	  {
	    /* got an error, return details */
	    regs_R[2] = errno;
	    regs_R[7] = 1;
	  }

	/* translate the stat structure to host format */
	ss_sbuf.ss_st_dev = SWAP_HALF(sbuf.st_dev);
	ss_sbuf.ss_st_ino = SWAP_WORD(sbuf.st_ino);
	ss_sbuf.ss_st_mode = SWAP_HALF(sbuf.st_mode);
	ss_sbuf.ss_st_nlink = SWAP_HALF(sbuf.st_nlink);
	ss_sbuf.ss_st_uid = SWAP_HALF(sbuf.st_uid);
	ss_sbuf.ss_st_gid = SWAP_HALF(sbuf.st_gid);
	ss_sbuf.ss_st_rdev = SWAP_HALF(sbuf.st_rdev);
	ss_sbuf.ss_st_size = SWAP_WORD(sbuf.st_size);
	ss_sbuf.ss_st_atime = SWAP_WORD(sbuf.st_atime);
	ss_sbuf.ss_st_mtime = SWAP_WORD(sbuf.st_mtime);
	ss_sbuf.ss_st_ctime = SWAP_WORD(sbuf.st_ctime);
	ss_sbuf.ss_st_blksize = SWAP_WORD(sbuf.st_blksize);
	ss_sbuf.ss_st_blocks = SWAP_WORD(sbuf.st_blocks);

	/* copy fstat() results to simulator memory */
	mem_bcopy(mem_fn, Write, /*sbuf*/regs_R[5],
		  &ss_sbuf, sizeof(struct ss_statbuf));
      }
      break;

    case SS_SYS_getpagesize:
      /* get target pagesize */
      regs_R[2] = /* was: getpagesize() */SS_PAGE_SIZE;

      /* check for an error condition */
      if (regs_R[2] != -1)
	regs_R[7] = 0;
      else
	{
	  /* got an error, return details */
	  regs_R[2] = errno;
	  regs_R[7] = 1;
	}
      break;

    case SS_SYS_setitimer:
      /* FIXME: the sigvec system call is ignored */
      regs_R[2] = regs_R[7] = 0;
      warn("syscall: setitimer ignored");
      break;

    case SS_SYS_getdtablesize:
#if defined(_AIX)
      /* get descriptor table size */
      regs_R[2] = getdtablesize();

      /* check for an error condition */
      if (regs_R[2] != -1)
	regs_R[7] = 0;
      else
	{
	  /* got an error, return details */
	  regs_R[2] = errno;
	  regs_R[7] = 1;
	}
#elif defined(__CYGWIN32__)
      {
	/* no comparable system call found, try some reasonable defaults */
	warn("syscall: called getdtablesize\n");
	regs_R[2] = 16;
	regs_R[7] = 0;
      }
#elif defined(ultrix)
      {
	/* no comparable system call found, try some reasonable defaults */
	warn("syscall: called getdtablesize\n");
	regs_R[2] = 16;
	regs_R[7] = 0;
      }
#else
      {
	struct rlimit rl;

	/* get descriptor table size in rlimit structure */
	if (getrlimit(RLIMIT_NOFILE, &rl) != -1)
	  {
	    regs_R[2] = rl.rlim_cur;
	    regs_R[7] = 0;
	  }
	else
	  {
	    /* got an error, return details */
	    regs_R[2] = errno;
	    regs_R[7] = 1;
	  }
      }
#endif
      break;

    case SS_SYS_dup2:
      /* dup2() the file descriptor */
      regs_R[2] = dup2(/* fd1 */regs_R[4], /* fd2 */regs_R[5]);

      /* check for an error condition */
      if (regs_R[2] != -1)
	regs_R[7] = 0;
      else
	{
	  /* got an error, return details */
	  regs_R[2] = errno;
	  regs_R[7] = 1;
	}
      break;

    case SS_SYS_fcntl:
      /* get fcntl() information on the file */
      regs_R[2] = fcntl(/*fd*/regs_R[4], /*cmd*/regs_R[5], /*arg*/regs_R[6]);

      /* check for an error condition */
      if (regs_R[2] != -1)
	regs_R[7] = 0;
      else
	{
	  /* got an error, return details */
	  regs_R[2] = errno;
	  regs_R[7] = 1;
	}
      break;

    case SS_SYS_select:
      {
	fd_set readfd, writefd, exceptfd;
	fd_set *readfdp, *writefdp, *exceptfdp;
	struct timeval timeout, *timeoutp;
	SS_WORD_TYPE param5;

	/* FIXME: swap words? */

	/* read the 5th parameter (timeout) from the stack */
	mem_bcopy(mem_fn, Read, regs_R[29]+16, &param5, sizeof(SS_WORD_TYPE));

	/* copy read file descriptor set into host memory */
	if (/*readfd*/regs_R[5] != 0)
	  {
	    mem_bcopy(mem_fn, Read, /*readfd*/regs_R[5],
		      &readfd, sizeof(fd_set));
	    readfdp = &readfd;
	  }
	else
	  readfdp = NULL;

	/* copy write file descriptor set into host memory */
	if (/*writefd*/regs_R[6] != 0)
	  {
	    mem_bcopy(mem_fn, Read, /*writefd*/regs_R[6],
		      &writefd, sizeof(fd_set));
	    writefdp = &writefd;
	  }