syscall.c

体系机构仿真

		  &ss_sbuf, sizeof(struct ss_statbuf));
      }
      break;

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

      /* 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_setitimer:
      /* FIXME: the sigvec system call is ignored */
      regs_R[pid][2] = regs_R[pid][7] = 0;
      warn("syscall: setitimer ignored");
      break;

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

      /* 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;
	}
#elif defined(__CYGWIN32__)
      {
	/* no comparable system call found, try some reasonable defaults */
	warn("syscall: called getdtablesize\n");
	regs_R[pid][2] = 16;
	regs_R[pid][7] = 0;
      }
#elif defined(ultrix)
      {
	/* no comparable system call found, try some reasonable defaults */
	warn("syscall: called getdtablesize\n");
	regs_R[pid][2] = 16;
	regs_R[pid][7] = 0;
      }
#else
      {
	struct rlimit rl;

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

    case SS_SYS_dup2:
      /* dup2() the file descriptor */
      regs_R[pid][2] = dup2(/* fd1 */regs_R[pid][4], /* fd2 */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_fcntl:
      /* get fcntl() information on the file */
      regs_R[pid][2] = fcntl(/*fd*/regs_R[pid][4], /*cmd*/regs_R[pid][5], /*arg*/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_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[pid][29]+16, &param5, sizeof(SS_WORD_TYPE));

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

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

	/* copy exception file descriptor set into host memory */
	if (/*exceptfd*/regs_R[pid][7] != 0)
	  {
	    mem_bcopy(mem_fn, Read, /*exceptfd*/regs_R[pid][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[pid][2] =
	  select(/*nfd*/regs_R[pid][4],
		 (int *)readfdp, (int *)writefdp, (int *)exceptfdp, timeoutp);
#else
	/* select() on the specified file descriptors */
	/*result*/regs_R[pid][2] =
	  select(/*nfd*/regs_R[pid][4], readfdp, writefdp, exceptfdp, timeoutp);
#endif

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

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

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

	/* copy exception file descriptor set to target memory */
	if (/*exceptfd*/regs_R[pid][7] != 0)
	  mem_bcopy(mem_fn, Write, /*exceptfd*/regs_R[pid][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[pid][2] = regs_R[pid][7] = 0;
      warn("syscall: sigvec ignored");
      break;

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

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

#if 0      
    case SS_SYS_sigstack:
      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[pid][4] != 0)
	  {
	    /* copy timeval into host memory */
	    mem_bcopy(mem_fn, Read, /*timeval*/regs_R[pid][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[pid][5] != 0)
	  {
	    /* copy timezone into host memory */
	    mem_bcopy(mem_fn, Read, /*timezone*/regs_R[pid][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[pid][2] = gettimeofday(tvp, tzp);

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

	if (/*timeval*/regs_R[pid][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[pid][4],
		      &ss_tv, sizeof(struct ss_timeval));
	  }

	if (/*timezone*/regs_R[pid][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[pid][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[pid][2] = 0;
	    regs_R[pid][7] = 0;
	  }
	else
	  {
	    /* got an error, indicate result */
	    regs_R[pid][2] = errno;
	    regs_R[pid][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[pid][5],
		  &rusage, sizeof(struct ss_rusage));
      }
#elif defined(__unix__)
      {
	struct rusage local_rusage;
	struct ss_rusage rusage;

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

	/* check for an error condition */
	if (regs_R[pid][2] != -1)
	  regs_R[pid][7] = 0;
	else
	  {
	    /* got an error, indicate result */
	    regs_R[pid][2] = errno;
	    regs_R[pid][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[pid][5],
		  &rusage, sizeof(struct ss_rusage));
      }
#elif defined(__CYGWIN32__)
	    warn("syscall: called getrusage\n");
            regs_R[pid][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[pid][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[pid][5],
		  iov, /*iovcnt*/regs_R[pid][6] * sizeof(struct iovec));

	/* copy target side I/O vector buffers to host memory */
	for (i=0; i < /*iovcnt*/regs_R[pid][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[pid][2] =
	  writev(/*fd*/regs_R[pid][4], iov, /*iovcnt*/regs_R[pid][6]);

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

	/* free all the allocated memory */
	for (i=0; i < /*iovcnt*/regs_R[pid][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[pid][4], buf);

	if (/*timeval*/regs_R[pid][5] == 0)
	  {
#if defined(hpux) || defined(__hpux) || defined(__i386__)
	    /* no utimes() in hpux, use utime() instead */
	    /*result*/regs_R[pid][2] = utime(buf, NULL);
#elif defined(__svr4__) || defined(__USLC__) || defined(unix) || defined(_AIX)
	    /*result*/regs_R[pid][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[pid][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);