413 lines
13 KiB
C++
413 lines
13 KiB
C++
// addrspace.cc
|
|
// Routines to manage address spaces (executing user programs).
|
|
//
|
|
// In order to run a user program, you must:
|
|
//
|
|
// 1. link with the -n -T 0 option
|
|
// 2. run coff2noff to convert the object file to Nachos format
|
|
// (Nachos object code format is essentially just a simpler
|
|
// version of the UNIX executable object code format)
|
|
// 3. load the NOFF file into the Nachos file system
|
|
// (if you are using the "stub" file system, you
|
|
// don't need to do this last step)
|
|
//
|
|
// Copyright (c) 1992-1996 The Regents of the University of California.
|
|
// All rights reserved. See copyright.h for copyright notice and limitation
|
|
// of liability and disclaimer of warranty provisions.
|
|
|
|
#include "copyright.h"
|
|
#include "main.h"
|
|
#include "addrspace.h"
|
|
#include "machine.h"
|
|
#include "noff.h"
|
|
|
|
//----------------------------------------------------------------------
|
|
// SwapHeader
|
|
// Do little endian to big endian conversion on the bytes in the
|
|
// object file header, in case the file was generated on a little
|
|
// endian machine, and we're now running on a big endian machine.
|
|
//----------------------------------------------------------------------
|
|
|
|
static void
|
|
SwapHeader (NoffHeader *noffH)
|
|
{
|
|
noffH->noffMagic = WordToHost(noffH->noffMagic);
|
|
noffH->code.size = WordToHost(noffH->code.size);
|
|
noffH->code.virtualAddr = WordToHost(noffH->code.virtualAddr);
|
|
noffH->code.inFileAddr = WordToHost(noffH->code.inFileAddr);
|
|
#ifdef RDATA
|
|
noffH->readonlyData.size = WordToHost(noffH->readonlyData.size);
|
|
noffH->readonlyData.virtualAddr =
|
|
WordToHost(noffH->readonlyData.virtualAddr);
|
|
noffH->readonlyData.inFileAddr =
|
|
WordToHost(noffH->readonlyData.inFileAddr);
|
|
#endif
|
|
noffH->initData.size = WordToHost(noffH->initData.size);
|
|
noffH->initData.virtualAddr = WordToHost(noffH->initData.virtualAddr);
|
|
noffH->initData.inFileAddr = WordToHost(noffH->initData.inFileAddr);
|
|
noffH->uninitData.size = WordToHost(noffH->uninitData.size);
|
|
noffH->uninitData.virtualAddr = WordToHost(noffH->uninitData.virtualAddr);
|
|
noffH->uninitData.inFileAddr = WordToHost(noffH->uninitData.inFileAddr);
|
|
|
|
#ifdef RDATA
|
|
DEBUG(dbgAddr, "code = " << noffH->code.size <<
|
|
" readonly = " << noffH->readonlyData.size <<
|
|
" init = " << noffH->initData.size <<
|
|
" uninit = " << noffH->uninitData.size << "\n");
|
|
#endif
|
|
}
|
|
|
|
FrameTable::Node::Node(int idx):
|
|
next(nullptr), idx(idx) {}
|
|
|
|
FrameTable::FrameTable()
|
|
{
|
|
available = NumPhysPages;
|
|
useCount = new int[NumPhysPages];
|
|
begin = end = new FrameTable::Node;
|
|
for (int i = 0; i < NumPhysPages; i++) {
|
|
useCount[i] = 0;
|
|
end->idx = i;
|
|
end->next = new FrameTable::Node;
|
|
end = end->next;
|
|
}
|
|
}
|
|
|
|
FrameTable::~FrameTable()
|
|
{
|
|
delete[] useCount;
|
|
while (begin != end) {
|
|
FrameTable::Node *tmpNode = begin;
|
|
begin = begin->next;
|
|
delete tmpNode;
|
|
}
|
|
delete begin;
|
|
}
|
|
|
|
int FrameTable::Allocate()
|
|
{
|
|
if (available == 0)
|
|
return -1;
|
|
|
|
int ret = begin->idx;
|
|
Node *tmp = begin;
|
|
begin = begin->next;
|
|
delete tmp;
|
|
|
|
--available;
|
|
useCount[ret]++;
|
|
|
|
bzero(kernel->machine->mainMemory + ret * PageSize, PageSize);
|
|
|
|
//cerr << "Allocated at page: " << ret << endl;
|
|
return ret;
|
|
}
|
|
|
|
void FrameTable::Release(int phyPageNum)
|
|
{
|
|
useCount[phyPageNum]--;
|
|
|
|
if (useCount[phyPageNum] > 0)
|
|
return;
|
|
|
|
++available;
|
|
|
|
//cerr << "Release page: " << end->idx << endl;
|
|
end->idx = phyPageNum;
|
|
end->next = new FrameTable::Node;
|
|
}
|
|
|
|
size_t FrameTable::RemainSize()
|
|
{
|
|
return available;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// AddrSpace::AddrSpace
|
|
// Create an address space to run a user program.
|
|
// Set up the translation from program memory to physical
|
|
// memory. For now, this is really simple (1:1), since we are
|
|
// only uniprogramming, and we have a single unsegmented page table
|
|
//----------------------------------------------------------------------
|
|
|
|
AddrSpace::AddrSpace()
|
|
{}
|
|
|
|
//----------------------------------------------------------------------
|
|
// AddrSpace::~AddrSpace
|
|
// Dealloate an address space.
|
|
//----------------------------------------------------------------------
|
|
|
|
AddrSpace::~AddrSpace()
|
|
{
|
|
for (int i = 0; i < NumPhysPages; i++)
|
|
if (pageTable[i].use == TRUE)
|
|
kernel->frameTable->Release(pageTable[i].physicalPage);
|
|
delete[] pageTable;
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
// AddrSpace::Load
|
|
// Load a user program into memory from a file.
|
|
//
|
|
// Assumes that the page table has been initialized, and that
|
|
// the object code file is in NOFF format.
|
|
//
|
|
// "fileName" is the file containing the object code to load into memory
|
|
//----------------------------------------------------------------------
|
|
|
|
bool
|
|
AddrSpace::Load(char *fileName)
|
|
{
|
|
//cerr << "AddrSpace::Load" << endl;
|
|
OpenFile *executable = kernel->fileSystem->Open(fileName);
|
|
NoffHeader noffH;
|
|
unsigned int size;
|
|
|
|
if (executable == NULL) {
|
|
cerr << "Unable to open file " << fileName << "\n";
|
|
return FALSE;
|
|
}
|
|
|
|
executable->ReadAt((char *)&noffH, sizeof(noffH), 0);
|
|
if ((noffH.noffMagic != NOFFMAGIC) &&
|
|
(WordToHost(noffH.noffMagic) == NOFFMAGIC))
|
|
SwapHeader(&noffH);
|
|
ASSERT(noffH.noffMagic == NOFFMAGIC);
|
|
|
|
#ifdef RDATA
|
|
// how big is address space?
|
|
size = noffH.code.size + noffH.readonlyData.size + noffH.initData.size +
|
|
noffH.uninitData.size + UserStackSize;
|
|
//cerr << noffH.code.size << ' '
|
|
// << noffH.readonlyData.size << ' '
|
|
// << noffH.initData.size << ' '
|
|
// << noffH.uninitData.size << ' '
|
|
// << UserStackSize << endl;
|
|
// we need to increase the size
|
|
// to leave room for the stack
|
|
#else
|
|
// how big is address space?
|
|
size = noffH.code.size + noffH.initData.size + noffH.uninitData.size
|
|
+ UserStackSize; // we need to increase the size
|
|
// to leave room for the stack
|
|
//cerr << noffH.code.size << ' '
|
|
// << noffH.initData.size << ' '
|
|
// << noffH.uninitData.size << ' '
|
|
// << UserStackSize << endl;
|
|
#endif
|
|
numPages = divRoundUp(size, PageSize);
|
|
size = numPages * PageSize;
|
|
|
|
ASSERT(numPages <= NumPhysPages); // check we're not trying
|
|
// to run anything too big --
|
|
// at least until we have
|
|
// virtual memory
|
|
|
|
pageTable = new TranslationEntry[numPages];
|
|
for (int i = 0; i < numPages; i++) {
|
|
pageTable[i].virtualPage = i;
|
|
pageTable[i].physicalPage = -1;
|
|
pageTable[i].valid = TRUE;
|
|
pageTable[i].use = FALSE;
|
|
pageTable[i].dirty = FALSE;
|
|
pageTable[i].readOnly = FALSE;
|
|
}
|
|
|
|
DEBUG(dbgAddr, "Initializing address space: " << numPages << ", " << size);
|
|
|
|
// then, copy in the code and data segments into memory
|
|
if (noffH.code.size > 0) {
|
|
DEBUG(dbgAddr, "Initializing code segment.");
|
|
DEBUG(dbgAddr, noffH.code.virtualAddr << ", " << noffH.code.size);
|
|
|
|
for (size_t cur = 0; cur < (size_t)noffH.code.size; cur += PageSize) {
|
|
size_t physAddr, size = min((size_t)PageSize, noffH.code.size - cur);
|
|
Translate(noffH.code.virtualAddr + cur, &physAddr, 1);
|
|
//cerr << "physAddr, size: " << physAddr << ' ' << size << endl;
|
|
|
|
executable->ReadAt(
|
|
&(kernel->machine->mainMemory[physAddr]), size,
|
|
noffH.code.inFileAddr + cur);
|
|
}
|
|
}
|
|
if (noffH.initData.size > 0) {
|
|
DEBUG(dbgAddr, "Initializing data segment.");
|
|
DEBUG(dbgAddr, noffH.initData.virtualAddr << ", " << noffH.initData.size);
|
|
|
|
for (size_t cur = 0; cur < (size_t)noffH.initData.size; cur += PageSize) {
|
|
size_t physAddr, size = min((size_t)PageSize, noffH.initData.size - cur);
|
|
Translate(noffH.initData.virtualAddr + cur, &physAddr, 1);
|
|
|
|
executable->ReadAt(
|
|
&(kernel->machine->mainMemory[physAddr]), size,
|
|
noffH.initData.inFileAddr + cur);
|
|
}
|
|
}
|
|
|
|
#ifdef RDATA
|
|
if (noffH.readonlyData.size > 0) {
|
|
DEBUG(dbgAddr, "Initializing read only data segment.");
|
|
DEBUG(dbgAddr, noffH.readonlyData.virtualAddr << ", " << noffH.readonlyData.size);
|
|
|
|
for (size_t cur = 0; cur < (size_t)noffH.readonlyData.size; cur += PageSize) {
|
|
size_t physAddr, size = min((size_t)PageSize, noffH.readonlyData.size - cur);
|
|
Translate(noffH.readonlyData.virtualAddr + cur, &physAddr, 1);
|
|
|
|
executable->ReadAt(
|
|
&(kernel->machine->mainMemory[physAddr]),
|
|
size, noffH.readonlyData.inFileAddr + cur);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
delete executable; // close file
|
|
return TRUE; // success
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// AddrSpace::Execute
|
|
// Run a user program using the current thread
|
|
//
|
|
// The program is assumed to have already been loaded into
|
|
// the address space
|
|
//
|
|
//----------------------------------------------------------------------
|
|
|
|
void
|
|
AddrSpace::Execute(char* fileName)
|
|
{
|
|
//cerr << "AddrSpace::Execute" << endl;
|
|
kernel->currentThread->space = this;
|
|
|
|
this->InitRegisters(); // set the initial register values
|
|
this->RestoreState(); // load page table register
|
|
|
|
kernel->machine->Run(); // jump to the user progam
|
|
|
|
ASSERTNOTREACHED(); // machine->Run never returns;
|
|
// the address space exits
|
|
// by doing the syscall "exit"
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
// AddrSpace::InitRegisters
|
|
// Set the initial values for the user-level register set.
|
|
//
|
|
// We write these directly into the "machine" registers, so
|
|
// that we can immediately jump to user code. Note that these
|
|
// will be saved/restored into the currentThread->userRegisters
|
|
// when this thread is context switched out.
|
|
//----------------------------------------------------------------------
|
|
|
|
void
|
|
AddrSpace::InitRegisters()
|
|
{
|
|
Machine *machine = kernel->machine;
|
|
int i;
|
|
|
|
for (i = 0; i < NumTotalRegs; i++)
|
|
machine->WriteRegister(i, 0);
|
|
|
|
// Initial program counter -- must be location of "Start", which
|
|
// is assumed to be virtual address zero
|
|
machine->WriteRegister(PCReg, 0);
|
|
|
|
// Need to also tell MIPS where next instruction is, because
|
|
// of branch delay possibility
|
|
// Since instructions occupy four bytes each, the next instruction
|
|
// after start will be at virtual address four.
|
|
machine->WriteRegister(NextPCReg, 4);
|
|
|
|
// Set the stack register to the end of the address space, where we
|
|
// allocated the stack; but subtract off a bit, to make sure we don't
|
|
// accidentally reference off the end!
|
|
machine->WriteRegister(StackReg, numPages * PageSize - 16);
|
|
DEBUG(dbgAddr, "Initializing stack pointer: " << numPages * PageSize - 16);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// AddrSpace::SaveState
|
|
// On a context switch, save any machine state, specific
|
|
// to this address space, that needs saving.
|
|
//
|
|
// For now, don't need to save anything!
|
|
//----------------------------------------------------------------------
|
|
|
|
void AddrSpace::SaveState()
|
|
{}
|
|
|
|
//----------------------------------------------------------------------
|
|
// AddrSpace::RestoreState
|
|
// On a context switch, restore the machine state so that
|
|
// this address space can run.
|
|
//
|
|
// For now, tell the machine where to find the page table.
|
|
//----------------------------------------------------------------------
|
|
|
|
void AddrSpace::RestoreState()
|
|
{
|
|
kernel->machine->pageTable = pageTable;
|
|
kernel->machine->pageTableSize = numPages;
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
// AddrSpace::Translate
|
|
// Translate the virtual address in _vaddr_ to a physical address
|
|
// and store the physical address in _paddr_.
|
|
// The flag _isReadWrite_ is false (0) for read-only access; true (1)
|
|
// for read-write access.
|
|
// Return any exceptions caused by the address translation.
|
|
//----------------------------------------------------------------------
|
|
ExceptionType
|
|
AddrSpace::Translate(unsigned int vaddr, unsigned int *paddr, int isReadWrite)
|
|
{
|
|
TranslationEntry *pte;
|
|
int pfn;
|
|
unsigned int vpn = vaddr / PageSize;
|
|
unsigned int offset = vaddr % PageSize;
|
|
|
|
if(vpn >= numPages) {
|
|
return AddressErrorException;
|
|
}
|
|
|
|
pte = &pageTable[vpn];
|
|
|
|
if(isReadWrite && pte->readOnly) {
|
|
return ReadOnlyException;
|
|
}
|
|
|
|
pfn = pte->physicalPage;
|
|
if (pfn == -1) {
|
|
pfn = pte->physicalPage = kernel->frameTable->Allocate();
|
|
if (pfn == -1) {
|
|
DEBUG(dbgAddr, "Memory Limit exceeded");
|
|
return MemoryLimitException;
|
|
}
|
|
}
|
|
|
|
// if the pageFrame is too big, there is something really wrong!
|
|
// An invalid translation was loaded into the page table or TLB.
|
|
if (pfn >= NumPhysPages) {
|
|
DEBUG(dbgAddr, "Illegal physical page " << pfn);
|
|
return BusErrorException;
|
|
}
|
|
|
|
pte->use = TRUE; // set the use, dirty bits
|
|
|
|
if(isReadWrite)
|
|
pte->dirty = TRUE;
|
|
|
|
*paddr = pfn * PageSize + offset;
|
|
|
|
ASSERT((*paddr < MemorySize));
|
|
|
|
//cerr << " -- AddrSpace::Translate(): vaddr: " << vaddr <<
|
|
// ", paddr: " << *paddr << "\n";
|
|
|
|
return NoException;
|
|
}
|