alpha_tru64_process.cc

linux下基于c++的处理器仿真平台。具有处理器流水线

	    break;

	  default:
	    warn("setsysinfo: unknown op %d\n", op);
	    break;
	}

	return 0;
    }

    /// Target fnctl() handler.
    static SyscallReturn
    fcntlFunc(SyscallDesc *desc, int callnum, Process *process,
	      ExecContext *xc)
    {
	int fd = xc->getSyscallArg(0);

	if (fd < 0 || process->sim_fd(fd) < 0)
	    return -EBADF;

	int cmd = xc->getSyscallArg(1);
	switch (cmd) {
	  case 0: // F_DUPFD
	    // if we really wanted to support this, we'd need to do it
	    // in the target fd space.
	    warn("fcntl(%d, F_DUPFD) not supported, error returned\n", fd);
	    return -EMFILE;

	  case 1: // F_GETFD (get close-on-exec flag)
	  case 2: // F_SETFD (set close-on-exec flag)
	    return 0;
	
	  case 3: // F_GETFL (get file flags)
	  case 4: // F_SETFL (set file flags)
	    // not sure if this is totally valid, but we'll pass it through
	    // to the underlying OS
	    warn("fcntl(%d, %d) passed through to host\n", fd, cmd);
	    return fcntl(process->sim_fd(fd), cmd);
	    // return 0;

	  case 7: // F_GETLK  (get lock)
	  case 8: // F_SETLK  (set lock)
	  case 9: // F_SETLKW (set lock and wait)
	    // don't mess with file locking... just act like it's OK
	    warn("File lock call (fcntl(%d, %d)) ignored.\n", fd, cmd);
	    return 0;

	  default:
	    warn("Unknown fcntl command %d\n", cmd);
	    return 0;
	}
    }

    
    /// Target getdirentries() handler.
    static SyscallReturn
    getdirentriesFunc(SyscallDesc *desc, int callnum, Process *process,
		      ExecContext *xc)
    {
#ifdef __CYGWIN__
        panic("getdirent not implemented on cygwin!");
#else
	int fd = process->sim_fd(xc->getSyscallArg(0));
	Addr tgt_buf = xc->getSyscallArg(1);
	int tgt_nbytes = xc->getSyscallArg(2);
	Addr tgt_basep = xc->getSyscallArg(3);

	char * const host_buf = new char[tgt_nbytes];

	// just pass basep through uninterpreted.
	TypedBufferArg<int64_t> basep(tgt_basep);
	basep.copyIn(xc->mem);
	long host_basep = (off_t)*basep;
	int host_result = getdirentries(fd, host_buf, tgt_nbytes, &host_basep);

	// check for error
	if (host_result < 0) {
	    delete [] host_buf;
	    return -errno;
	}

	// no error: copy results back to target space
	Addr tgt_buf_ptr = tgt_buf;
	char *host_buf_ptr = host_buf;
	char *host_buf_end = host_buf + host_result;
	while (host_buf_ptr < host_buf_end) {
	    global_dirent *host_dp = (global_dirent *)host_buf_ptr;
	    int namelen = strlen(host_dp->d_name);

	    // Actual size includes padded string rounded up for alignment.
	    // Subtract 256 for dummy char array in Tru64::dirent definition.
	    // Add 1 to namelen for terminating null char.
	    int tgt_bufsize = sizeof(Tru64::dirent) - 256 + RoundUp(namelen+1, 8);
	    TypedBufferArg<Tru64::dirent> tgt_dp(tgt_buf_ptr, tgt_bufsize);
	    tgt_dp->d_ino = host_dp->d_ino;
	    tgt_dp->d_reclen = tgt_bufsize;
	    tgt_dp->d_namlen = namelen;
	    strcpy(tgt_dp->d_name, host_dp->d_name);
	    tgt_dp.copyOut(xc->mem);

	    tgt_buf_ptr += tgt_bufsize;
	    host_buf_ptr += host_dp->d_reclen;
	}

	delete [] host_buf;

	*basep = host_basep;
	basep.copyOut(xc->mem);

	return tgt_buf_ptr - tgt_buf;
#endif
    }

    /// Target sigreturn() handler.
    static SyscallReturn
    sigreturnFunc(SyscallDesc *desc, int callnum, Process *process,
		  ExecContext *xc)
    {
	RegFile *regs = &xc->regs;
	TypedBufferArg<Tru64::sigcontext> sc(xc->getSyscallArg(0));

	sc.copyIn(xc->mem);

	// Restore state from sigcontext structure.
	// Note that we'll advance PC <- NPC before the end of the cycle,
	// so we need to restore the desired PC into NPC.
	// The current regs->pc will get clobbered.
	regs->npc = sc->sc_pc;

	for (int i = 0; i < 31; ++i) {
	    regs->intRegFile[i] = sc->sc_regs[i];
	    regs->floatRegFile.q[i] = sc->sc_fpregs[i];
	}

	regs->miscRegs.fpcr = sc->sc_fpcr;

	return 0;
    }

    /// Target table() handler.
    static SyscallReturn
    tableFunc(SyscallDesc *desc, int callnum, Process *process,
	      ExecContext *xc)
    {
	int id = xc->getSyscallArg(0);		// table ID
	int index = xc->getSyscallArg(1);	// index into table
	// arg 2 is buffer pointer; type depends on table ID
	int nel = xc->getSyscallArg(3);		// number of elements
	int lel = xc->getSyscallArg(4);		// expected element size

	switch (id) {
	  case Tru64::TBL_SYSINFO: {
	      if (index != 0 || nel != 1 || lel != sizeof(Tru64::tbl_sysinfo))
		  return -EINVAL;
	      TypedBufferArg<Tru64::tbl_sysinfo> elp(xc->getSyscallArg(2));

	      const int clk_hz = one_million;
	      elp->si_user = curTick / (Clock::Frequency / clk_hz);
	      elp->si_nice = 0;
	      elp->si_sys = 0;
	      elp->si_idle = 0;
	      elp->wait = 0;
	      elp->si_hz = clk_hz;
	      elp->si_phz = clk_hz;
	      elp->si_boottime = seconds_since_epoch; // seconds since epoch?
	      elp->si_max_procs = process->numCpus();
	      elp.copyOut(xc->mem);
	      return 0;
	  }

	  default:
	    cerr << "table(): id " << id << " unknown." << endl;
	    return -EINVAL;
	}
    }

    /// Array of syscall descriptors, indexed by call number.
    static SyscallDesc syscallDescs[];

    /// Number of syscalls in syscallDescs[].
    static const int Num_Syscall_Descs;

    /// Max supported syscall number.
    static const int Max_Syscall_Desc;

    //
    // Mach syscalls -- identified by negated syscall numbers
    //

    /// Create a stack region for a thread.
    static SyscallReturn
    stack_createFunc(SyscallDesc *desc, int callnum, Process *process,
		     ExecContext *xc)
    {
	TypedBufferArg<Tru64::vm_stack> argp(xc->getSyscallArg(0));

	argp.copyIn(xc->mem);

	// if the user chose an address, just let them have it.  Otherwise
	// pick one for them.
	if (argp->address == 0) {
	    argp->address = process->next_thread_stack_base;
	    int stack_size = (argp->rsize + argp->ysize + argp->gsize);
	    process->next_thread_stack_base -= stack_size;
	    argp.copyOut(xc->mem);
	}

	return 0;
    }

    /// NXM library version stamp.
    static
    const int NXM_LIB_VERSION = 301003;

    /// This call sets up the interface between the user and kernel
    /// schedulers by creating a shared-memory region.  The shared memory
    /// region has several structs, some global, some per-RAD, some per-VP.
    static SyscallReturn
    nxm_task_initFunc(SyscallDesc *desc, int callnum, Process *process,
		      ExecContext *xc)
    {
	TypedBufferArg<Tru64::nxm_task_attr> attrp(xc->getSyscallArg(0));
	TypedBufferArg<Addr> configptr_ptr(xc->getSyscallArg(1));

	attrp.copyIn(xc->mem);

	if (attrp->nxm_version != NXM_LIB_VERSION) {
	    cerr << "nxm_task_init: thread library version mismatch! "
		 << "got " << attrp->nxm_version
		 << ", expected " << NXM_LIB_VERSION << endl;
	    abort();
	}

	if (attrp->flags != Tru64::NXM_TASK_INIT_VP) {
	    cerr << "nxm_task_init: bad flag value " << attrp->flags
		 << " (expected " << Tru64::NXM_TASK_INIT_VP << ")" << endl;
	    abort();
	}

	const Addr base_addr = 0x12000; // was 0x3f0000000LL;
	Addr cur_addr = base_addr; // next addresses to use
	// first comes the config_info struct
	Addr config_addr = cur_addr;
	cur_addr += sizeof(Tru64::nxm_config_info);
	// next comes the per-cpu state vector
	Addr slot_state_addr = cur_addr;
	int slot_state_size =
	    process->numCpus() * sizeof(Tru64::nxm_slot_state_t);
	cur_addr += slot_state_size;
	// now the per-RAD state struct (we only support one RAD)
	cur_addr = 0x14000;	// bump up addr for alignment
	Addr rad_state_addr = cur_addr;
	int rad_state_size =
	    (sizeof(Tru64::nxm_shared)
	     + (process->numCpus()-1) * sizeof(Tru64::nxm_sched_state));
	cur_addr += rad_state_size;

	// now initialize a config_info struct and copy it out to user space
	TypedBufferArg<Tru64::nxm_config_info> config(config_addr);

	config->nxm_nslots_per_rad = process->numCpus();
	config->nxm_nrads = 1;	// only one RAD in our system!
	config->nxm_slot_state = slot_state_addr;
	config->nxm_rad[0] = rad_state_addr;

	config.copyOut(xc->mem);

	// initialize the slot_state array and copy it out
	TypedBufferArg<Tru64::nxm_slot_state_t> slot_state(slot_state_addr,
							   slot_state_size);
	for (int i = 0; i < process->numCpus(); ++i) {
	    // CPU 0 is bound to the calling process; all others are available
	    slot_state[i] =
		(i == 0) ? Tru64::NXM_SLOT_BOUND : Tru64::NXM_SLOT_AVAIL;
	}

	slot_state.copyOut(xc->mem);

	// same for the per-RAD "shared" struct.  Note that we need to
	// allocate extra bytes for the per-VP array which is embedded at
	// the end.
	TypedBufferArg<Tru64::nxm_shared> rad_state(rad_state_addr,
						    rad_state_size);

	rad_state->nxm_callback = attrp->nxm_callback;
	rad_state->nxm_version = attrp->nxm_version;
	rad_state->nxm_uniq_offset = attrp->nxm_uniq_offset;
	for (int i = 0; i < process->numCpus(); ++i) {
	    Tru64::nxm_sched_state *ssp = &rad_state->nxm_ss[i];
	    ssp->nxm_u.sigmask = 0;
	    ssp->nxm_u.sig = 0;
	    ssp->nxm_u.flags = 0;
	    ssp->nxm_u.cancel_state = 0;
	    ssp->nxm_u.nxm_ssig = 0;
	    ssp->nxm_bits = 0;
	    ssp->nxm_quantum = attrp->nxm_quantum;
	    ssp->nxm_set_quantum = attrp->nxm_quantum;
	    ssp->nxm_sysevent = 0;

	    if (i == 0) {
		uint64_t uniq = xc->regs.miscRegs.uniq;
		ssp->nxm_u.pth_id = uniq + attrp->nxm_uniq_offset;
		ssp->nxm_u.nxm_active = uniq | 1;
	    }
	    else {
		ssp->nxm_u.pth_id = 0;
		ssp->nxm_u.nxm_active = 0;
	    }
	}

	rad_state.copyOut(xc->mem);

	//
	// copy pointer to shared config area out to user
	//
	*configptr_ptr = config_addr;
	configptr_ptr.copyOut(xc->mem);

	// Register this as a valid address range with the process
	process->nxm_start = base_addr;
	process->nxm_end = cur_addr;

	return 0;
    }

    /// Initialize execution context.
    static void
    init_exec_context(ExecContext *ec,
		      Tru64::nxm_thread_attr *attrp, uint64_t uniq_val)
    {
	memset(&ec->regs, 0, sizeof(ec->regs));

	ec->regs.intRegFile[ArgumentReg0] = attrp->registers.a0;
	ec->regs.intRegFile[27/*t12*/] = attrp->registers.pc;
	ec->regs.intRegFile[StackPointerReg] = attrp->registers.sp;
	ec->regs.miscRegs.uniq = uniq_val;

	ec->regs.pc = attrp->registers.pc;
	ec->regs.npc = attrp->registers.pc + sizeof(MachInst);

	ec->activate();
    }

    /// Create thread.
    static SyscallReturn
    nxm_thread_createFunc(SyscallDesc *desc, int callnum, Process *process,
			  ExecContext *xc)
    {
	TypedBufferArg<Tru64::nxm_thread_attr> attrp(xc->getSyscallArg(0));
	TypedBufferArg<uint64_t> kidp(xc->getSyscallArg(1));
	int thread_index = xc->getSyscallArg(2);

	// get attribute args
	attrp.copyIn(xc->mem);

	if (attrp->version != NXM_LIB_VERSION) {
	    cerr << "nxm_thread_create: thread library version mismatch! "
		 << "got " << attrp->version
		 << ", expected " << NXM_LIB_VERSION << endl;
	    abort();
	}

	if (thread_index < 0 | thread_index > process->numCpus()) {
	    cerr << "nxm_thread_create: bad thread index " << thread_index
		 << endl;
	    abort();
	}

	// On a real machine, the per-RAD shared structure is in
	// shared memory, so both the user and kernel can get at it.
	// We don't have that luxury, so we just copy it in and then
	// back out again.
	int rad_state_size =
	    (sizeof(Tru64::nxm_shared) +
	     (process->numCpus()-1) * sizeof(Tru64::nxm_sched_state));

	TypedBufferArg<Tru64::nxm_shared> rad_state(0x14000,
						    rad_state_size);