traps.cc

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

    return_value = errno * -1;

  memset(&solbuf, 0, sizeof(solbuf));
  solbuf.st_dev          = endian_swap((unsigned int)sbuf.st_dev);
  solbuf.st_ino          = endian_swap((long long)sbuf.st_ino);
  solbuf.st_mode         = endian_swap(sbuf.st_mode);
  solbuf.st_nlink        = endian_swap(sbuf.st_nlink);
  solbuf.st_uid          = endian_swap(sbuf.st_uid);
  solbuf.st_gid          = endian_swap(sbuf.st_gid);
  solbuf.st_rdev         = endian_swap((unsigned int)sbuf.st_rdev);
  solbuf.st_size         = endian_swap(sbuf.st_size);
#ifdef linux
  solbuf.st_atim.tv_sec  = endian_swap(sbuf.st_atime);
  solbuf.st_atim.tv_nsec = 0;
  solbuf.st_mtim.tv_sec  = endian_swap(sbuf.st_mtime);
  solbuf.st_mtim.tv_nsec = 0;
  solbuf.st_ctim.tv_sec  = endian_swap(sbuf.st_ctime);
  solbuf.st_ctim.tv_nsec = 0;
#else
  solbuf.st_atim.tv_sec  = endian_swap(sbuf.st_atim.tv_sec);
  solbuf.st_atim.tv_nsec = endian_swap(sbuf.st_atim.tv_nsec);
  solbuf.st_mtim.tv_sec  = endian_swap(sbuf.st_mtim.tv_sec);
  solbuf.st_mtim.tv_nsec = endian_swap(sbuf.st_mtim.tv_nsec);
  solbuf.st_ctim.tv_sec  = endian_swap(sbuf.st_ctim.tv_sec);
  solbuf.st_ctim.tv_nsec = endian_swap(sbuf.st_ctim.tv_nsec);
#endif
  solbuf.st_blksize      = endian_swap(sbuf.st_blksize);
  solbuf.st_blocks       = endian_swap(sbuf.st_blocks);
#ifndef linux
  memcpy(solbuf.st_fstype, sbuf.st_fstype, sizeof(sbuf.st_fstype));
#else
  solbuf.st_fstype[0] = '\0';
#endif

  memcpy(buf, &solbuf, sizeof(solbuf));

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

  proc->phy_int_reg_file[return_register] =
    proc->log_int_reg_file[lreturn_register] = return_value;    
}


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


static void DFStat64Handler(instance *inst, ProcState *proc)
{
#ifdef COREFILE
  if (YS__Simtime > DEBUG_TIME)
    fprintf(corefile,"traps.cc: In Stat Handler\n");
#endif
 
  int                    pr, i, fd;
  char                   buffer[PATH_MAX]; 
  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];
  inst->addr = base;

  memset(buffer, 0, sizeof(buffer));
  for (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)];
  base = proc->phy_int_reg_file[pr];

  return_value = 0;
  if (fd != -1)
    return_value = FD_fchdir(fd);
  if (return_value == 0)
    return_value = lstat64(buffer, &sbuf);
  if (return_value < 0)
    return_value = errno * -1;

  memset(&solbuf, 0, sizeof(solbuf));
  solbuf.st_dev          = endian_swap((unsigned int)sbuf.st_dev);
  solbuf.st_ino          = endian_swap((long long)sbuf.st_ino);
  solbuf.st_mode         = endian_swap(sbuf.st_mode);
  solbuf.st_nlink        = endian_swap(sbuf.st_nlink);
  solbuf.st_uid          = endian_swap(sbuf.st_uid);
  solbuf.st_gid          = endian_swap(sbuf.st_gid);
  solbuf.st_rdev         = endian_swap((unsigned int)sbuf.st_rdev);
  solbuf.st_size         = endian_swap(sbuf.st_size);
#ifdef linux
  solbuf.st_atim.tv_sec  = endian_swap(sbuf.st_atime);
  solbuf.st_atim.tv_nsec = 0;
  solbuf.st_mtim.tv_sec  = endian_swap(sbuf.st_mtime);
  solbuf.st_mtim.tv_nsec = 0;
  solbuf.st_ctim.tv_sec  = endian_swap(sbuf.st_ctime);
  solbuf.st_ctim.tv_nsec = 0;
#else
  solbuf.st_atim.tv_sec  = endian_swap(sbuf.st_atim.tv_sec);
  solbuf.st_atim.tv_nsec = endian_swap(sbuf.st_atim.tv_nsec);
  solbuf.st_mtim.tv_sec  = endian_swap(sbuf.st_mtim.tv_sec);
  solbuf.st_mtim.tv_nsec = endian_swap(sbuf.st_mtim.tv_nsec);
  solbuf.st_ctim.tv_sec  = endian_swap(sbuf.st_ctim.tv_sec);
  solbuf.st_ctim.tv_nsec = endian_swap(sbuf.st_ctim.tv_nsec);
#endif
  solbuf.st_blksize      = endian_swap(sbuf.st_blksize);
  solbuf.st_blocks       = endian_swap(sbuf.st_blocks);
#ifndef linux
  memcpy(solbuf.st_fstype, sbuf.st_fstype, sizeof(sbuf.st_fstype));
#else
  solbuf.st_fstype[0] = '\0';
#endif

  memcpy(buf, &solbuf, sizeof(solbuf));

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

  proc->phy_int_reg_file[return_register] =
    proc->log_int_reg_file[lreturn_register] = return_value;    
}
 
 
/***************************************************************************/


static void Lstat64Handler(instance *inst, ProcState *proc)
{
#ifdef COREFILE
  if (YS__Simtime > DEBUG_TIME)
    fprintf(corefile,"traps.cc: In LStat Handler\n");
#endif
 
  int                    pr, i;
  char                   buffer[PATH_MAX]; 
  struct stat64          sbuf;
  struct solaris_stat64  solbuf;
  int                    return_value;
  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)];
  base = proc->phy_int_reg_file[pr];
  inst->addr = base;

  memset(buffer, 0, sizeof(buffer));
  for (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, 9)];
  base = proc->phy_int_reg_file[pr];

  return_value = lstat64(buffer, &sbuf);

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

  memset(&solbuf, 0, sizeof(solbuf));
  solbuf.st_dev          = endian_swap((unsigned int)sbuf.st_dev);
  solbuf.st_ino          = endian_swap((long long)sbuf.st_ino);
  solbuf.st_mode         = endian_swap(sbuf.st_mode);
  solbuf.st_nlink        = endian_swap(sbuf.st_nlink);
  solbuf.st_uid          = endian_swap(sbuf.st_uid);
  solbuf.st_gid          = endian_swap(sbuf.st_gid);
  solbuf.st_rdev         = endian_swap((unsigned int)sbuf.st_rdev);
  solbuf.st_size         = endian_swap(sbuf.st_size);
#ifdef linux
  solbuf.st_atim.tv_sec  = endian_swap(sbuf.st_atime);
  solbuf.st_atim.tv_nsec = 0;
  solbuf.st_mtim.tv_sec  = endian_swap(sbuf.st_mtime);
  solbuf.st_mtim.tv_nsec = 0;
  solbuf.st_ctim.tv_sec  = endian_swap(sbuf.st_ctime);
  solbuf.st_ctim.tv_nsec = 0;
#else
  solbuf.st_atim.tv_sec  = endian_swap(sbuf.st_atim.tv_sec);
  solbuf.st_atim.tv_nsec = endian_swap(sbuf.st_atim.tv_nsec);
  solbuf.st_mtim.tv_sec  = endian_swap(sbuf.st_mtim.tv_sec);
  solbuf.st_mtim.tv_nsec = endian_swap(sbuf.st_mtim.tv_nsec);
  solbuf.st_ctim.tv_sec  = endian_swap(sbuf.st_ctim.tv_sec);
  solbuf.st_ctim.tv_nsec = endian_swap(sbuf.st_ctim.tv_nsec);
#endif
  solbuf.st_blksize      = endian_swap(sbuf.st_blksize);
  solbuf.st_blocks       = endian_swap(sbuf.st_blocks);
#ifndef linux
  memcpy(solbuf.st_fstype, sbuf.st_fstype, sizeof(sbuf.st_fstype));
#else
  solbuf.st_fstype[0] = '\0';
#endif

  memcpy(buf, &solbuf, sizeof(solbuf));

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

  proc->phy_int_reg_file[return_register] =
    proc->log_int_reg_file[lreturn_register] = return_value;    
}



/***************************************************************************/
/* ChmodHandler : Simulator exception routine that handles chmod           */
/***************************************************************************/

static void ChmodHandler(instance *inst, ProcState *proc)
{
#ifdef COREFILE
  if (YS__Simtime > DEBUG_TIME)
    fprintf(corefile,"traps.cc: In Chmod Handler\n");
#endif
  
  int   fd, mode;
  int   lr;
  int   pr;
  int   return_value;
  char  buffer[PATH_MAX], *pa;
  
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 8)];
  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, 9)];
  mode = proc->phy_int_reg_file[pr];
 
  return_value = chmod(buffer, mode);

  if (return_value < 0)
    return_value = errno * -1;
  
  lr = arch_to_log(proc, proc->cwp, 8);
  pr = proc->intmapper[lr];
  proc->phy_int_reg_file[pr] =
    proc->log_int_reg_file[lr] = return_value;
}



/***************************************************************************/
/* FchmodHandler : Simulator exception routine that handles fchmod         */
/***************************************************************************/

static void FchmodHandler(instance *, ProcState *proc)
{
#ifdef COREFILE
  if (YS__Simtime > DEBUG_TIME)
    fprintf(corefile,"traps.cc: In Fchmod Handler\n");
#endif
  
  int fd, mode;
  int lr;
  int pr;
  int return_value = -1;
 
  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)];
  mode = proc->phy_int_reg_file[pr];

  fd = FD_open(fd);
  if (fd >= 0)
    {
      return_value = fchmod(fd, mode);
      close(fd);
    }
  if (return_value < 0)
    return_value = errno * -1;
  
  lr = arch_to_log(proc, proc->cwp, 8);
  pr = proc->intmapper[lr];
  proc->phy_int_reg_file[pr] =
    proc->log_int_reg_file[lr] = return_value;
}
 



/***************************************************************************/
/* ChownHandler : Simulator exception routine that handles chown           */
/***************************************************************************/

static void ChownHandler(instance *inst, ProcState *proc)
{
#ifdef COREFILE
  if (YS__Simtime > DEBUG_TIME)
    fprintf(corefile,"traps.cc: In Chown Handler\n");
#endif
  
  int   fd, uid, gid;
  int   lr;
  int   pr;
  int   return_value;
  char  buffer[PATH_MAX], *pa;
  
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 8)];
  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, 9)];
  uid = proc->phy_int_reg_file[pr];
 
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 10)];
  gid = proc->phy_int_reg_file[pr];
 
  return_value = chown(buffer, uid, gid);

  if (return_value < 0)
    return_value = errno * -1;
  
  lr = arch_to_log(proc, proc->cwp, 8);
  pr = proc->intmapper[lr];
  proc->phy_int_reg_file[pr] =
    proc->log_int_reg_file[lr] = return_value;
}



/***************************************************************************/
/* FchownHandler : Simulator exception routine that handles fchown         */
/***************************************************************************/

static void FchownHandler(instance *, ProcState *proc)
{
#ifdef COREFILE
  if (YS__Simtime > DEBUG_TIME)
    fprintf(corefile,"traps.cc: In Fchown Handler\n");
#endif
  
  int fd, uid, gid;
  int lr;
  int pr;
  int return_value = -1;
 
  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)];
  uid = proc->phy_int_reg_file[pr];
 
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 10)];
  gid = proc->phy_int_reg_file[pr];

  fd = FD_open(fd);
  if (fd >= 0)
    {
      return_value = fchown(fd, uid, gid);
      close(fd);
    }
  if (return_value < 0)
    return_value = errno * -1;
  
  lr = arch_to_log(proc, proc->cwp, 8);
  pr = proc->intmapper[lr];
  proc->phy_int_reg_file[pr] =
    proc->log_int_reg_file[lr] = return_value;
}
 



/***************************************************************************/
/* LchownHandler : Simulator exception routine that handles lchown         */
/***************************************************************************/

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

  int   fd, uid, gid;
  int   lr;
  int   pr;
  int   return_value;
  char  buffer[PATH_MAX], *pa;
  
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 8)];
  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