traps.cc

ml-rsim 多处理器模拟器 支持类bsd操作系统

  return_value = FD_remove(fd);
  if (return_value < 0)
    return_value = errno * -1;

  proc->phy_int_reg_file[pr] =
    proc->log_int_reg_file[lr] = return_value;
}
 
 
/***************************************************************************/


static void DUnlinkHandler(instance *inst, ProcState *proc)
{
#ifdef COREFILE
  if (YS__Simtime > DEBUG_TIME)
    fprintf(corefile,"traps.cc: In Unlink Handler\n");
#endif

  int  pr, fd;
  char buffer[PATH_MAX]; 
  int  return_value;
  int  lreturn_register;
  int  return_register;
  char *pa;

  lreturn_register = arch_to_log(proc, proc->cwp, 8);
  return_register = proc->intmapper[lreturn_register];
 
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 8)];
  fd = proc->phy_int_reg_file[pr];
 
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 9)];
  inst->addr = proc->phy_int_reg_file[pr];

  memset(buffer, 0, sizeof(buffer));
  for (int i = 0; i < PATH_MAX-1; i++)
    {
      pa = (char *)GetMap(inst, proc);
      buffer[i] = *pa;
      if (*pa == '\0')
        break;
      inst->addr++;
    }

  return_value = 0;
  if (fd != -1)
    return_value = FD_fchdir(fd);
  if (return_value == 0)
    return_value = unlink(buffer);

  if (return_value < 0)
    return_value = errno * -1;
 
  proc->phy_int_reg_file[return_register] =
    proc->log_int_reg_file[lreturn_register] = return_value;    
}
 
 
/***************************************************************************/


static void DAccessHandler(instance *inst, ProcState *proc)
{
#ifdef COREFILE
  if (YS__Simtime > DEBUG_TIME)
    fprintf(corefile,"traps.cc: In Access Handler\n");
#endif
 
  int  pr;
  char buffer[PATH_MAX]; 
  int  mode, fd;
  int  return_value;
  int  lreturn_register;
  int  return_register;
  char *pa;
 
  lreturn_register = arch_to_log(proc, proc->cwp, 8);
  return_register = proc->intmapper[lreturn_register];
 
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 8)];
  fd = proc->phy_int_reg_file[pr];
 
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 9)];
  inst->addr = proc->phy_int_reg_file[pr];

  memset(buffer, 0, sizeof(buffer));
  for (int i = 0; i < PATH_MAX-1; i++)
    {
      pa = (char *)GetMap(inst, proc);
      buffer[i] = *pa;
      if (*pa == '\0')
        break;
      inst->addr++;
    }
 
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 10)];
  mode = proc->phy_int_reg_file[pr];

  return_value = 0;
  if (fd != -1)
    return_value = FD_fchdir(fd);
  if (return_value == 0)
    return_value = access(buffer, mode);

  if (return_value < 0)
    return_value = errno * -1;
 
  proc->phy_int_reg_file[return_register] =
    proc->log_int_reg_file[lreturn_register] = return_value;    
}
 
 
/***************************************************************************/


static void IoctlHandler(instance *inst, ProcState *proc)
{
#ifdef COREFILE
  if (YS__Simtime > DEBUG_TIME)
    fprintf(corefile,"traps.cc: In Ioctl Handler\n");
#endif
 
  int   pr;
  int   fd, request, arg, size;
  int   return_value = -1;
  int   lreturn_register;
  int   return_register;
  char *buf = NULL, *pa;
 
  lreturn_register = arch_to_log(proc, proc->cwp, 8);
  return_register = proc->intmapper[lreturn_register];
 
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 8)];
  fd = proc->phy_int_reg_file[pr];
 
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 9)];
  request = proc->phy_int_reg_file[pr];

  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 10)];
  arg = proc->phy_int_reg_file[pr];

  size = (request >> 16) & 0xFF;

  if (request & IOC_INOUT)
    {
      buf = (char*)malloc(size);
      if (buf == NULL)
	YS__errmsg(proc->proc_id / ARCH_cpus,
		   "SimIoctl: Malloc failed: %s\n",
		   YS__strerror(errno));
      memset(buf, 0, size);
    }

  if (request & IOC_IN)      // copy third argument
    {
      inst->addr = arg;
      for (int i = 0; i < size; i++)
	{
	  pa = (char *)GetMap(inst, proc);
	  buf[i] = *pa;
	  inst->addr++;
	}
    }

  fd = FD_open(fd);
  if (fd >= 0)
    {
      return_value = ioctl(fd, request, buf);
      close(fd);
    }

  if (request & IOC_OUT)      // copy result from buffer
    {
      inst->addr = arg;
      for (int i = 0; i < size; i++)
	{
	  pa = (char *)GetMap(inst, proc);
	  *pa = buf[i];
	  inst->addr++;
	}
    }


  if (return_value < 0)
    return_value = errno * -1;
 
  proc->phy_int_reg_file[return_register] =
    proc->log_int_reg_file[lreturn_register] = return_value;

  if (buf != NULL)
    free(buf);
}

/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
/*                                                                          */
/*                  We haven't finished fcntl for linux yet!                */
/*                                                                          */
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
/*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/

/***************************************************************************/

typedef struct solaris_flock
{
  short         l_type;
  short         l_whence;
  unsigned long l_start;
  unsigned long l_len;
  long          l_sysid;
  unsigned long l_pid;
} solaris_flock_t;


typedef struct solaris_flock64
{
  short         l_type;
  short         l_whence;
  long long     l_start;
  long long     l_len;
  long          l_sysid;
  unsigned long l_pid;
} solaris_flock64_t;

static void fcntl_panic(int proc_id, int request)
{
  YS__errmsg(proc_id / ARCH_cpus,
		   "SimFcntl: unknown request: %d\n",
		   request);
}

#define SOL_F_DUPFD		0
#define SOL_F_GETFD		1
#define SOL_F_SETFD		2
#define SOL_F_GETFL		3
#define SOL_F_SETFL		4
#define SOL_F_SETLK		6
#define SOL_F_SETLKW		7
#define SOL_F_CHKFL		8
#define SOL_F_DUP2FD		9
#define SOL_F_ALLOCSP		10
#define SOL_F_FREESP		11
#define SOL_F_ISSTREAM		13
#define SOL_F_GETLK		14
#define SOL_F_PRIV		15
#define SOL_F_NPRIV		16
#define SOL_F_QUOTACTL		17
#define SOL_F_BLOCKS		18
#define SOL_F_BLKSIZE		19
#define SOL_F_RSETLK		20
#define SOL_F_RGETLK		21
#define SOL_F_RSETLKW		22
#define SOL_F_GETOWN		23
#define SOL_F_SETOWN		24
#define SOL_F_REVOKE		25
#define SOL_F_HASREMOTELOCKS	26
#define SOL_F_FREESP64		27
#define SOL_F_GETLK64		33
#define SOL_F_SETLK64		34
#define SOL_F_SETLKW64		35
#define SOL_F_SHARE		40
#define SOL_F_UNSHARE		41

static void FcntlHandler(instance *inst, ProcState *proc)
{
#ifdef COREFILE
  if (YS__Simtime > DEBUG_TIME)
    fprintf(corefile,"traps.cc: In Fcntl Handler\n");
#endif
 
  int                    pr;
  int                    fd, request, arg;
  int                    return_value = -1;
  int                    lreturn_register;
  int                    return_register;
  char                  *buf = NULL, *pa;
  struct solaris_flock   sfl;
  struct solaris_flock64 sfl64;
  long long		 l_start;
 
  lreturn_register = arch_to_log(proc, proc->cwp, 8);
  return_register = proc->intmapper[lreturn_register];
 
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 8)];
  fd = proc->phy_int_reg_file[pr];
 
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 9)];
  request = proc->phy_int_reg_file[pr];

  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 10)];
  arg = proc->phy_int_reg_file[pr];

  // case request -> host_request
  //              -> function
  //              -> copy out?
  //              -> 64 vs. 32 bit flock
  //              -> other structures

  // It is believed that the only request fcntl is used for anymore is freesp!
  // For now, let's only handle that case.  If it turns out not to be true, we
  // can go back and deal w/ it.
  if (request != SOL_F_FREESP && request != SOL_F_FREESP64)
    fcntl_panic(proc->proc_id, request);

  if (request == SOL_F_FREESP)
    {  
      buf = (char*)malloc(sizeof(struct solaris_flock));
      if (buf == NULL)
	YS__errmsg(proc->proc_id / ARCH_cpus,
		   "SimFcntl: Malloc Failed: %s\n",
		   YS__strerror(errno));
      memset(buf, 0, sizeof(struct solaris_flock));

      inst->addr = arg;
      for (int i = 0; i < sizeof(struct solaris_flock); i++)
	{
	  pa = (char *)GetMap(inst, proc);
	  buf[i] = *pa;
	  inst->addr++;
	}

      if (endian_swap(((struct solaris_flock*)buf)->l_whence) != SEEK_SET)
	YS__errmsg(proc->proc_id / ARCH_cpus,
		   "SimFcntl: F_FREESP: l_whence != SEEK_SET!\n");

      if (endian_swap(((struct solaris_flock*)buf)->l_len) != 0)
	YS__errmsg(proc->proc_id / ARCH_cpus,
		   "SimFcntl: F_FREESP: l_len != 0!\n");

      l_start = endian_swap(((struct solaris_flock*)buf)->l_start);
    }

  if (request == SOL_F_FREESP64)
    {
      buf = (char*)malloc(sizeof(struct solaris_flock64));
      if (buf == NULL)
	YS__errmsg(proc->proc_id / ARCH_cpus,
		   "SimFcntl: Malloc Failed: %s\n",
		   YS__strerror(errno));
      memset(buf, 0, sizeof(struct solaris_flock64));

      inst->addr = arg;
      for (int i = 0; i < sizeof(struct solaris_flock64); i++)
	{
	  pa = (char *)GetMap(inst, proc);
	  buf[i] = *pa;
	  inst->addr++;
	}

      if (endian_swap(((struct solaris_flock64*)buf)->l_whence) != SEEK_SET)
	YS__errmsg(proc->proc_id / ARCH_cpus,
		   "SimFcntl: F_FREESP: l_whence != SEEK_SET!\n");

      if (endian_swap(((struct solaris_flock64*)buf)->l_len) != 0)
	YS__errmsg(proc->proc_id / ARCH_cpus,
		   "SimFcntl: F_FREESP: l_len != 0!\n");

      l_start = endian_swap(((struct solaris_flock64*)buf)->l_start);
    }


  fd = FD_open(fd);
  if (fd >= 0)
    {
      return_value = ftruncate(fd, l_start);
      close(fd);
    }

  if (return_value < 0)
    return_value = errno * -1;
 
  proc->phy_int_reg_file[return_register] =
    proc->log_int_reg_file[lreturn_register] = return_value;

  if (buf)
    free(buf);
}




/***************************************************************************/

// Operating systems other than Solaris may have a different layout of the
// stat structure. Thus, we copy only the elements needed for the Solaris
// version from the native structure. Reference native elements by name,
// simulated structure (RSIM/Solaris) by offset/length

// Solaris 2.5 definition of the user stat structure

struct solaris_stat64
{
  unsigned long         st_dev;                  // 32 bit
  long                  st_pad1[3];              // 3 x 32 bit
  unsigned long long    st_ino;                  // 64 bit
  mode_t                st_mode;                 // 32 bit
  nlink_t               st_nlink;                // 32 bit
  uid_t                 st_uid;                  // 32 bit
  gid_t                 st_gid;                  // 32 bit
  unsigned long         st_rdev;                 // 32 bit
  long                  st_pad2[2];              // 2 x 32 bit
#ifdef PAD_STAT64
  long                  st_pad3;                 // 32 bit
#endif
  long long             st_size;                 // 64 bit
  timespec_t            st_atim;                 // 2 x 32 bit
  timespec_t            st_mtim;                 // 2 x 32 bit
  timespec_t            st_ctim;                 // 2 x 32 bit
  long                  st_blksize;              // 32 bit
#ifdef PAD_STAT64
  long                  st_pad5;                 // 32 bit
#endif
  long long             st_blocks;               // 64 bit
  char                  st_fstype[_ST_FSTYPSZ];  // 16 x 8 bit
  long                  st_pad4[8];              // 8 x 32 bit
};


static void Fstat64Handler(instance *inst, ProcState *proc)
{
#ifdef COREFILE
  if (YS__Simtime > DEBUG_TIME)
    fprintf(corefile,"traps.cc: In FStat Handler\n");
#endif
 
  int                    pr;
  int                    fd, i;
  struct stat64          sbuf;
  struct solaris_stat64  solbuf;
  int                    return_value = -1;
  int                    lreturn_register;
  int                    return_register;
  char                  *pa;
  char                   buf[sizeof(struct solaris_stat64)];
  unsigned               base;

  lreturn_register = arch_to_log(proc, proc->cwp, 8);
  return_register = proc->intmapper[lreturn_register];

  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 8)];
  fd = proc->phy_int_reg_file[pr];
 
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 9)];
  base = proc->phy_int_reg_file[pr];

  fd = FD_open(fd);
  if (fd >= 0)
    {
      return_value = fstat64(fd, &sbuf);
      close(fd);
    }
  if (return_value < 0)