traps.cc

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

    }
  
  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 = FD_create(buffer, O_WRONLY | O_CREAT | O_TRUNC, 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 DOpenHandler(instance *inst, ProcState *proc)
{
#ifdef COREFILE
  if (YS__Simtime > DEBUG_TIME)
    fprintf(corefile,"traps.cc: In Open Handler\n");
#endif

  int  pr;
  char buffer[PATH_MAX]; 
  int  oflag;
  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)];
  oflag = proc->phy_int_reg_file[pr];
 
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 11)];
  mode = proc->phy_int_reg_file[pr];

  return_value = 0;
  if (fd != -1)
    return_value = FD_fchdir(fd);
  if (return_value == 0)
    return_value = FD_create(buffer, oflag, 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;    
}


/***************************************************************************/
/* PReadHandler : Simulator exception routine that handles read            */
/***************************************************************************/
 
static void PRead64Handler(instance *inst, ProcState *proc)
{
 
#ifdef COREFILE
  if (YS__Simtime > DEBUG_TIME)
    fprintf(corefile,"traps.cc: In PRead Handler\n");
#endif
  
  int       fd, number_of_items;
  char     *buffer;
  int       pr;
  int       count = 0;
  int       lreturn_register;
  int       return_register;
  int       retval, done, v0, v1;
  long long offset;
  /* read the parameters */
 
  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];

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

  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 11)];
  v0 = proc->phy_int_reg_file[pr];

  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 12)];
  v1 = proc->phy_int_reg_file[pr];

  offset = (long long)v0 << 32 | (long long)v1;

  /* do one character at a time - can be optimized */

  int st = inst->addr & (PAGE_SIZE - 1);

  done = 0;
  fd = FD_open(fd);
  if (fd < 0)
    {
      count = -1;
      done = 1;
    }
  
  if ((done == 0) && (number_of_items > PAGE_SIZE - st))
    {
      buffer = GetMap(inst, proc);
      retval = (int)pread64(fd, buffer, PAGE_SIZE-st, offset);
      if (retval < 0)
	count = retval;
      else
	{
	  count += retval;
	  number_of_items -= retval;
	  inst->addr += retval;
	  offset += retval;
	}
 
      if (retval != PAGE_SIZE - st)
        done = 1;
      
      while (!done && (number_of_items >= PAGE_SIZE))
        {
          buffer = GetMap(inst, proc);
          retval = (int)pread64(fd, buffer, PAGE_SIZE, offset);
	  
          if (retval < 0)             /* some sort of error other than EOF */
            count = retval;
          else
            {
              count += retval;
              number_of_items -= retval;
              inst->addr += retval;
	      offset += retval;
            }

          if (retval != PAGE_SIZE)
            {
              done = 1;
              break;
            }
        }
    }
      
  buffer = GetMap(inst, proc);
 
  if (!done)
    {
      retval = (int)pread64(fd, buffer, number_of_items, offset);
      if (retval < 0)                 /* some sort of error other than EOF */
        count = retval;
      else
        count += retval;
    }

  close(fd);

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

  proc->phy_int_reg_file[return_register] =
    proc->log_int_reg_file[lreturn_register] = count;
}
 
 
 
/***************************************************************************/
/* PWriteHandler : Simulator exception routine that handles write          */
/***************************************************************************/

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

  int       fd, number_of_items;
  char     *buffer;
  int       pr;
  int       count = 0;
  int       lreturn_register;
  int       return_register;
  int       retval, done, v0, v1;
  long long offset;

  /*read the parameters */
 
  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];
 
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 10)];
  number_of_items = proc->phy_int_reg_file[pr];
 
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 11)];
  v0 = proc->phy_int_reg_file[pr];
  
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 12)];
  v1 = proc->phy_int_reg_file[pr];

  offset = (long long)v0 << 32 | (long long)v1;
  
  int st = inst->addr & (PAGE_SIZE - 1);

  done = 0;
  fd = FD_open(fd);
  if (fd < 0)
    {
      count = -1;
      done = 1;
    }
  
  if ((done == 0) && (number_of_items > PAGE_SIZE - st))
    {
      buffer = GetMap(inst, proc);

      retval = (int)pwrite64(fd, buffer, PAGE_SIZE-st, offset);
      count += retval;
      inst->addr += retval;
      number_of_items -= retval;
      offset += retval;
 
      if (retval != PAGE_SIZE-st)
        done = 1;

      while (number_of_items >= PAGE_SIZE)
        {
          buffer = GetMap(inst, proc);

          retval = (int)pwrite64(fd, buffer, PAGE_SIZE, offset);
          if (retval < 0)             /* some sort of error other than EOF */
            count = retval;
          else
            {
              count += retval;
              number_of_items -= retval;
              inst->addr += retval;
	      offset += retval;
            }
          
          if (retval != PAGE_SIZE)
            {
              done = 1;
              break;
            }
        }
    }
      
  buffer = GetMap(inst, proc);
  
  if (!done)
    {
      retval = (int)pwrite64(fd, buffer, number_of_items, offset);

      if (retval < 0)                 /* some sort of error other than EOF */
        count = retval;
      else
        count += retval;
    }
 
  if (count < 0)
    count = -1 * errno;
  fflush(NULL);
  close(fd);

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



/***************************************************************************/
/* LseekHandler : Simulator exception routine that handles lseek           */
/***************************************************************************/
 
static void Lseek64Handler(instance *, ProcState *proc)
{
#ifdef COREFILE
  if (YS__Simtime > DEBUG_TIME)
    fprintf(corefile,"traps.cc: In Lseek Handler\n");
#endif
  
  int       fd, whence, v0, v1;
  long long position;
  int       lreturn_register0, lreturn_register1;
  int       return_register0, return_register1;
  long long return_value;
  int       pr;
  
  /* read parameters */
  lreturn_register0 = arch_to_log(proc, proc->cwp, 8);
  lreturn_register1 = arch_to_log(proc, proc->cwp, 9);
  return_register0 = proc->intmapper[lreturn_register0];
  return_register1 = proc->intmapper[lreturn_register1];
  
  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)];
  v0 = proc->phy_int_reg_file[pr];
 
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 10)];
  v1 = proc->phy_int_reg_file[pr];

  position = (long long)v0 << 32 | (long long)v1;
  
  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 11)];
  whence = proc->phy_int_reg_file[pr];

  return_value = FD_lseek(fd, position, whence);

  if (return_value < 0)
    {
      proc->phy_int_reg_file[return_register0] =
	proc->log_int_reg_file[lreturn_register0] = -errno;
      proc->phy_int_reg_file[return_register1] =
	proc->log_int_reg_file[lreturn_register1] = 0;
    }
  else
    {
      proc->phy_int_reg_file[return_register0] =
	proc->log_int_reg_file[lreturn_register0] = return_value >> 32;
      proc->phy_int_reg_file[return_register1] =
	proc->log_int_reg_file[lreturn_register1] = return_value;
    }
}
 
 
 
 
/***************************************************************************/
/* ReadlinkHandler : Simulator exception routine that handles readlink     */
/***************************************************************************/
 
static void ReadlinkHandler(instance *inst, ProcState *proc)
{
#ifdef COREFILE
  if (YS__Simtime > DEBUG_TIME)
    fprintf(corefile,"traps.cc: In ReadLink Handler\n");
#endif
 
  int   fd, length;
  int   lreturn_register;
  int   return_register;
  int   return_value;
  int   pr, i;
  char  path[PATH_MAX], *buf, *pa;
 
  /* read parameters */
  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(path, 0, sizeof(path));
  for (i = 0; i < PATH_MAX-1; i++)
    {
      pa = (char *)GetMap(inst, proc);
      path[i] = *pa;
      if (*pa == '\0')
        break;
      inst->addr++;
    }

  pr = proc->intmapper[arch_to_log(proc, proc->cwp, 11)];
  length = proc->phy_int_reg_file[pr];

  buf = (char*)malloc(length);
  if (buf == NULL)
    YS__errmsg(proc->proc_id / ARCH_cpus,
	       "SimReadLink: Malloc failed: %s\n",
	       YS__strerror(errno));
  memset(buf, 0, length);

  if (fd != -1)
    return_value = FD_fchdir(fd);
  if (return_value == 0)
    return_value = readlink(path, buf, length);

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

  for (i = 0; i < length; i++)
    {
      pa = (char *)GetMap(inst, proc);
      *pa = buf[i];
      inst->addr++;
    }
  free(buf);
  
  if (return_value < 0)
    return_value = errno * -1;
  
  proc->phy_int_reg_file[return_register] =
    proc->log_int_reg_file[lreturn_register] = return_value;
}


/***************************************************************************/
/* CloseHandler : Simulator exception routine that handles close           */
/***************************************************************************/

static void CloseHandler(instance *, ProcState *proc)
{
#ifdef COREFILE
  if (YS__Simtime > DEBUG_TIME)
    fprintf(corefile,"traps.cc: In Close Handler\n");
#endif
  
  int fd;
  int lr;
  int pr;
  int return_value;
 
  lr = arch_to_log(proc, proc->cwp, 8);
  pr = proc->intmapper[lr];
  fd = proc->phy_int_reg_file[pr];