syscall.c

体系机构仿真

	    regs_R[pid][7] = 1;
	  }
      }
      break;

    case SS_SYS_close:
      /* don't close stdin, stdout, or stderr as this messes up sim logs */
      if (/*fd*/regs_R[pid][4] == 0 || /*fd*/regs_R[pid][4] == 1 || /*fd*/regs_R[pid][4] == 2)
	{
	  regs_R[pid][7] = 0;
	  break;
	}

      /* close the file */
      regs_R[pid][2] = close(/*fd*/regs_R[pid][4]);

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

    case SS_SYS_creat:
      {
	char buf[MAXBUFSIZE];

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

	/* create the file */
	/*fd*/regs_R[pid][2] = creat(buf, /*mode*/regs_R[pid][5]);

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

    case SS_SYS_unlink:
      {
	char buf[MAXBUFSIZE];

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

	/* delete the file */
	/*result*/regs_R[pid][2] = unlink(buf);

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

    case SS_SYS_chdir:
      {
	char buf[MAXBUFSIZE];

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

	/* change the working directory */
	/*result*/regs_R[pid][2] = chdir(buf);

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

    case SS_SYS_chmod:
      {
	char buf[MAXBUFSIZE];

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

	/* chmod the file */
	/*result*/regs_R[pid][2] = chmod(buf, /*mode*/regs_R[pid][5]);

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

    case SS_SYS_chown:
      {
	char buf[MAXBUFSIZE];

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

	/* chown the file */
	/*result*/regs_R[pid][2] = chown(buf, /*owner*/regs_R[pid][5],
				    /*group*/regs_R[pid][6]);

	/* check for an error condition */
	if (regs_R[pid][2] != -1)
	  regs_R[pid][7] = 0;
	else
	  {
	    /* got an error, return details */
	    regs_R[pid][2] = errno;
	    regs_R[pid][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[pid][4], SS_PAGE_SIZE);

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

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

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

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

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

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

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

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

    case SS_SYS_access:
      {
	char buf[MAXBUFSIZE];

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

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

	/* check for an error condition */
	if (regs_R[pid][2] != -1)
	  regs_R[pid][7] = 0;
	else
	  {
	    /* got an error, return details */
	    regs_R[pid][2] = errno;
	    regs_R[pid][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[pid][4], buf);

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

	/* check for an error condition */
	if (regs_R[pid][2] != -1)
	  regs_R[pid][7] = 0;
	else
	  {
	    /* got an error, return details */
	    regs_R[pid][2] = errno;
	    regs_R[pid][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[pid][5],
		  &ss_sbuf, sizeof(struct ss_statbuf));
      }
      break;

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

      /* check for an error condition */
      if (regs_R[pid][2] != -1)
	regs_R[pid][7] = 0;
      else
	{
	  /* got an error, return details */
	  regs_R[pid][2] = errno;
	  regs_R[pid][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[pid][4], fd, sizeof(fd));

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

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

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

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

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

	/* check for an error condition */
      if (regs_R[pid][2] != -1)
	regs_R[pid][7] = 0;
      else
	{
	  /* got an error, return details */
	  regs_R[pid][2] = errno;
	  regs_R[pid][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[pid][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[pid][4], regs_R[pid][5]);
	    regs_R[pid][2] = 0;
	    regs_R[pid][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[pid][6] != 0)
	      mem_bcopy(mem_fn, Read, /*argp*/regs_R[pid][6], buf, NUM_IOCTL_BYTES);

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

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

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

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

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

	/* check for an error condition */
	if (regs_R[pid][2] != -1)
	  regs_R[pid][7] = 0;
	else
	  {
	    /* got an error, return details */
	    regs_R[pid][2] = errno;
	    regs_R[pid][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[pid][5],