syscall.c

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

	else
	  writefdp = NULL;

	/* copy exception file descriptor set into host memory */
	if (/*exceptfd*/regs_R[7] != 0)
	  {
	    mem_bcopy(mem_fn, Read, /*exceptfd*/regs_R[7],
		      &exceptfd, sizeof(fd_set));
	    exceptfdp = &exceptfd;
	  }
	else
	  exceptfdp = NULL;

	/* copy timeout value into host memory */
	if (/*timeout*/param5 != 0)
	  {
	    mem_bcopy(mem_fn, Read, /*timeout*/param5,
		      &timeout, sizeof(struct timeval));
	    timeoutp = &timeout;
	  }
	else
	  timeoutp = NULL;

#if defined(hpux) || defined(__hpux)
	/* select() on the specified file descriptors */
	/*result*/regs_R[2] =
	  select(/*nfd*/regs_R[4],
		 (int *)readfdp, (int *)writefdp, (int *)exceptfdp, timeoutp);
#else
	/* select() on the specified file descriptors */
	/*result*/regs_R[2] =
	  select(/*nfd*/regs_R[4], readfdp, writefdp, exceptfdp, timeoutp);
#endif

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

	/* copy read file descriptor set to target memory */
	if (/*readfd*/regs_R[5] != 0)
	  mem_bcopy(mem_fn, Write, /*readfd*/regs_R[5],
		    &readfd, sizeof(fd_set));

	/* copy write file descriptor set to target memory */
	if (/*writefd*/regs_R[6] != 0)
	  mem_bcopy(mem_fn, Write, /*writefd*/regs_R[6],
		    &writefd, sizeof(fd_set));

	/* copy exception file descriptor set to target memory */
	if (/*exceptfd*/regs_R[7] != 0)
	  mem_bcopy(mem_fn, Write, /*exceptfd*/regs_R[7],
		    &exceptfd, sizeof(fd_set));

	/* copy timeout value result to target memory */
	if (/* timeout */param5 != 0)
	  mem_bcopy(mem_fn, Write, /*timeout*/param5,
		    &timeout, sizeof(struct timeval));
      }
      break;

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

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

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

#if 0
    case SS_SYS_sigstack:
      /* FIXME: this is broken... */
      /* do not make the system call; instead, modify (the stack
	 portion of) the simulator's main memory, ignore the 1st
	 argument (regs_R[4]), as it relates to signal handling */
      if (regs_R[5] != 0)
	{
	  (*maf)(Read, regs_R[29]+28, (unsigned char *)&temp, 4);
	  (*maf)(Write, regs_R[5], (unsigned char *)&temp, 4);
	}
      regs_R[2] = regs_R[7] = 0;
      break;
#endif

    case SS_SYS_gettimeofday:
      {
	struct ss_timeval ss_tv;
	struct timeval tv, *tvp;
	struct ss_timezone ss_tz;
	struct timezone tz, *tzp;

	if (/*timeval*/regs_R[4] != 0)
	  {
	    /* copy timeval into host memory */
	    mem_bcopy(mem_fn, Read, /*timeval*/regs_R[4],
		      &ss_tv, sizeof(struct ss_timeval));

	    /* convert target timeval structure to host format */
	    tv.tv_sec = SWAP_WORD(ss_tv.ss_tv_sec);
	    tv.tv_usec = SWAP_WORD(ss_tv.ss_tv_usec);
	    tvp = &tv;
	  }
	else
	  tvp = NULL;

	if (/*timezone*/regs_R[5] != 0)
	  {
	    /* copy timezone into host memory */
	    mem_bcopy(mem_fn, Read, /*timezone*/regs_R[5],
		      &ss_tz, sizeof(struct ss_timezone));

	    /* convert target timezone structure to host format */
	    tz.tz_minuteswest = SWAP_WORD(ss_tz.ss_tz_minuteswest);
	    tz.tz_dsttime = SWAP_WORD(ss_tz.ss_tz_dsttime);
	    tzp = &tz;
	  }
	else
	  tzp = NULL;

	/* get time of day */
	/*result*/regs_R[2] = gettimeofday(tvp, tzp);

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

	if (/*timeval*/regs_R[4] != 0)
	  {
	    /* convert host timeval structure to target format */
	    ss_tv.ss_tv_sec = SWAP_WORD(tv.tv_sec);
	    ss_tv.ss_tv_usec = SWAP_WORD(tv.tv_usec);

	    /* copy timeval to target memory */
	    mem_bcopy(mem_fn, Write, /*timeval*/regs_R[4],
		      &ss_tv, sizeof(struct ss_timeval));
	  }

	if (/*timezone*/regs_R[5] != 0)
	  {
	    /* convert host timezone structure to target format */
	    ss_tz.ss_tz_minuteswest = SWAP_WORD(tz.tz_minuteswest);
	    ss_tz.ss_tz_dsttime = SWAP_WORD(tz.tz_dsttime);

	    /* copy timezone to target memory */
	    mem_bcopy(mem_fn, Write, /*timezone*/regs_R[5],
		      &ss_tz, sizeof(struct ss_timezone));
	  }
      }
      break;

    case SS_SYS_getrusage:
#if defined(__svr4__) || defined(__USLC__) || defined(hpux) || defined(__hpux) || defined(_AIX)
      {
	struct tms tms_buf;
	struct ss_rusage rusage;

	/* get user and system times */
	if (times(&tms_buf) != -1)
	  {
	    /* no error */
	    regs_R[2] = 0;
	    regs_R[7] = 0;
	  }
	else
	  {
	    /* got an error, indicate result */
	    regs_R[2] = errno;
	    regs_R[7] = 1;
	  }

	/* initialize target rusage result structure */
#if defined(__svr4__)
	memset(&rusage, '\0', sizeof(struct ss_rusage));
#else /* !defined(__svr4__) */
	bzero(&rusage, sizeof(struct ss_rusage));
#endif

	/* convert from host rusage structure to target format */
	rusage.ss_ru_utime.ss_tv_sec = tms_buf.tms_utime/CLK_TCK;
	rusage.ss_ru_utime.ss_tv_sec = SWAP_WORD(rusage.ss_ru_utime.ss_tv_sec);
	rusage.ss_ru_utime.ss_tv_usec = 0;
	rusage.ss_ru_stime.ss_tv_sec = tms_buf.tms_stime/CLK_TCK;
	rusage.ss_ru_stime.ss_tv_sec = SWAP_WORD(rusage.ss_ru_stime.ss_tv_sec);
	rusage.ss_ru_stime.ss_tv_usec = 0;

	/* copy rusage results into target memory */
	mem_bcopy(mem_fn, Write, /*rusage*/regs_R[5],
		  &rusage, sizeof(struct ss_rusage));
      }
#elif defined(__unix__)
      {
	struct rusage local_rusage;
	struct ss_rusage rusage;

	/* get rusage information */
	/*result*/regs_R[2] = getrusage(/*who*/regs_R[4], &local_rusage);

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

	/* convert from host rusage structure to target format */
	rusage.ss_ru_utime.ss_tv_sec = local_rusage.ru_utime.tv_sec;
	rusage.ss_ru_utime.ss_tv_usec = local_rusage.ru_utime.tv_usec;
	rusage.ss_ru_utime.ss_tv_sec = SWAP_WORD(local_rusage.ru_utime.tv_sec);
	rusage.ss_ru_utime.ss_tv_usec = SWAP_WORD(local_rusage.ru_utime.tv_usec);
	rusage.ss_ru_stime.ss_tv_sec = local_rusage.ru_stime.tv_sec;
	rusage.ss_ru_stime.ss_tv_usec = local_rusage.ru_stime.tv_usec;
	rusage.ss_ru_stime.ss_tv_sec = SWAP_WORD(local_rusage.ru_stime.tv_sec);
	rusage.ss_ru_stime.ss_tv_usec = SWAP_WORD(local_rusage.ru_stime.tv_usec);
	rusage.ss_ru_maxrss = SWAP_WORD(local_rusage.ru_maxrss);
	rusage.ss_ru_ixrss = SWAP_WORD(local_rusage.ru_ixrss);
	rusage.ss_ru_idrss = SWAP_WORD(local_rusage.ru_idrss);
	rusage.ss_ru_isrss = SWAP_WORD(local_rusage.ru_isrss);
	rusage.ss_ru_minflt = SWAP_WORD(local_rusage.ru_minflt);
	rusage.ss_ru_majflt = SWAP_WORD(local_rusage.ru_majflt);
	rusage.ss_ru_nswap = SWAP_WORD(local_rusage.ru_nswap);
	rusage.ss_ru_inblock = SWAP_WORD(local_rusage.ru_inblock);
	rusage.ss_ru_oublock = SWAP_WORD(local_rusage.ru_oublock);
	rusage.ss_ru_msgsnd = SWAP_WORD(local_rusage.ru_msgsnd);
	rusage.ss_ru_msgrcv = SWAP_WORD(local_rusage.ru_msgrcv);
	rusage.ss_ru_nsignals = SWAP_WORD(local_rusage.ru_nsignals);
	rusage.ss_ru_nvcsw = SWAP_WORD(local_rusage.ru_nvcsw);
	rusage.ss_ru_nivcsw = SWAP_WORD(local_rusage.ru_nivcsw);

	/* copy rusage results into target memory */
	mem_bcopy(mem_fn, Write, /*rusage*/regs_R[5],
		  &rusage, sizeof(struct ss_rusage));
      }
#elif defined(__CYGWIN32__)
	    warn("syscall: called getrusage\n");
            regs_R[7] = 0;
#else
#error No getrusage() implementation!
#endif
      break;

    case SS_SYS_writev:
      {
	int i;
	char *buf;
	struct iovec *iov;

	/* allocate host side I/O vectors */
	iov =
	  (struct iovec *)malloc(/*iovcnt*/regs_R[6] * sizeof(struct iovec));
	if (!iov)
	  fatal("out of virtual memory in SYS_writev");

	/* copy target side pointer data into host side vector */
	mem_bcopy(mem_fn, Read, /*iov*/regs_R[5],
		  iov, /*iovcnt*/regs_R[6] * sizeof(struct iovec));

	/* copy target side I/O vector buffers to host memory */
	for (i=0; i < /*iovcnt*/regs_R[6]; i++)
	  {
	    iov[i].iov_base = (char *)SWAP_WORD((unsigned)iov[i].iov_base);
	    iov[i].iov_len = SWAP_WORD(iov[i].iov_len);
	    if (iov[i].iov_base != NULL)
	      {
		buf = (char *)calloc(iov[i].iov_len, sizeof(char));
		if (!buf)
		  fatal("out of virtual memory in SYS_writev");
		mem_bcopy(mem_fn, Read, (SS_ADDR_TYPE)iov[i].iov_base,
			  buf, iov[i].iov_len);
		iov[i].iov_base = buf;
	      }
	  }

	/* perform the vector'ed write */
	/*result*/regs_R[2] =
	  writev(/*fd*/regs_R[4], iov, /*iovcnt*/regs_R[6]);

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

	/* free all the allocated memory */
	for (i=0; i < /*iovcnt*/regs_R[6]; i++)
	  {
	    if (iov[i].iov_base)
	      {
		free(iov[i].iov_base);
		iov[i].iov_base = NULL;
	      }
	  }
	free(iov);
      }
      break;

    case SS_SYS_utimes:
      {
	char buf[MAXBUFSIZE];

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

	if (/*timeval*/regs_R[5] == 0)
	  {
#if defined(hpux) || defined(__hpux) || defined(__i386__)
	    /* no utimes() in hpux, use utime() instead */
	    /*result*/regs_R[2] = utime(buf, NULL);
#elif defined(__svr4__) || defined(__USLC__) || defined(unix) || defined(_AIX)
	    /*result*/regs_R[2] = utimes(buf, NULL);
#elif defined(__CYGWIN32__)
	    warn("syscall: called utimes\n");
#else
#error No utimes() implementation!
#endif
	  }
	else
	  {
	    struct ss_timeval ss_tval[2];
	    struct timeval tval[2];

	    /* copy timeval structure to host memory */
	    mem_bcopy(mem_fn, Read, /*timeout*/regs_R[5],
		      ss_tval, 2*sizeof(struct ss_timeval));

	    /* convert timeval structure to host format */
	    tval[0].tv_sec = SWAP_WORD(ss_tval[0].ss_tv_sec);
	    tval[0].tv_usec = SWAP_WORD(ss_tval[0].ss_tv_usec);
	    tval[1].tv_sec = SWAP_WORD(ss_tval[1].ss_tv_sec);
	    tval[1].tv_usec = SWAP_WORD(ss_tval[1].ss_tv_usec);

#if defined(hpux) || defined(__hpux)
	    /* no utimes() in hpux, use utime() instead */
	    {
	      struct utimbuf ubuf;

	      ubuf.actime = tval[0].tv_sec;
	      ubuf.modtime = tval[1].tv_sec;

	      /* result */regs_R[2] = utime(buf, &ubuf);
	    }
#elif defined(__svr4__) || defined(__USLC__) || defined(unix) || defined(_AIX)
	    /* result */regs_R[2] = utimes(buf, tval);
#elif defined(__CYGWIN32__)
	    warn("syscall: called utimes\n");
#else
#error No utimes() implementation!
#endif
	  }

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

    case SS_SYS_getrlimit:
    case SS_SYS_setrlimit:
#if defined(__CYGWIN32__)
      {
	warn("syscall: called get/setrlimit\n");
	regs_R[7] = 0;
      }
#else
      {
	struct rlimit ss_rl;
	struct rlimit rl;

	/* copy rlimit structure to host memory */
	mem_bcopy(mem_fn, Read, /*rlimit*/regs_R[5],
		  &ss_rl, sizeof(struct ss_rlimit));

	/* convert rlimit structure to host format */
	rl.rlim_cur = SWAP_WORD(ss_rl.rlim_cur);
	rl.rlim_max = SWAP_WORD(ss_rl.rlim_max);

	/* get rlimit information */
	if (syscode == SS_SYS_getrlimit)
	  /*result*/regs_R[2] = getrlimit(regs_R[4], &rl);
	else /* syscode == SS_SYS_setrlimit */
	  /*result*/regs_R[2] = setrlimit(regs_R[4], &rl);

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

	/* convert rlimit structure to target format */
	ss_rl.rlim_cur = SWAP_WORD(rl.rlim_cur);
	ss_rl.rlim_max = SWAP_WORD(rl.rlim_max);

	/* copy rlimit structure to target memory */
	mem_bcopy(mem_fn, Write, /*rlimit*/regs_R[5],
		  &ss_rl, sizeof(struct ss_rlimit));
      }
#endif
      break;

#if 0
    case SS_SYS_getdirentries:
      /* FIXME: this is currently broken due to incompatabilities in
	 disk directory formats */
      {
	unsigned int i;
	char *buf;
	int base;

	buf = (char *)calloc(/* nbytes */regs_R[6] + 1, sizeof(char));
	if (!buf)
	  fatal("out of memory in SYS_getdirentries");

	/* copy in */
	for (i=0; i</* nbytes */regs_R[6]; i++)
	  (*maf)(Read, /* buf */regs_R[5]+i, (unsigned char *)&buf[i], 1);
	(*maf)(Read, /* basep */regs_R[7], (unsigned char *)&base, 4);

	/*cc*/regs_R[2] =
	  getdirentries(/*fd*/regs_R[4], buf, /*nbytes*/regs_R[6], &base);

	if (regs_R[2] != -1)
	  regs_R[7] = 0;
	else
	  {
	    regs_R[2] = errno;
	    regs_R[7] = 1;
	  }

	/* copy out */
	for (i=0; i</* nbytes */regs_R[6]; i++)
	  (*maf)(Write, /* buf */regs_R[5]+i, (unsigned char *)&buf[i], 1);
	(*maf)(Write, /* basep */regs_R[7], (unsigned char *)&base, 4);

	free(buf);
      }
      break;
#endif

    default:
      panic("invalid/unimplemented system call encountered, code %d", syscode);
    }
}