// 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
}

//----------------------------------------------------------------------
// 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()
{
    pageTable = NULL; // initialize with NULL
    /*
        pageTable = new TranslationEntry[NumPhysPages];
        for (int i = 0; i < NumPhysPages; i++) {
        pageTable[i].virtualPage = i;	// for now, virt page # = phys page #
        pageTable[i].physicalPage = i;
        pageTable[i].valid = TRUE;
        pageTable[i].use = FALSE;
        pageTable[i].dirty = FALSE;
        pageTable[i].readOnly = FALSE;
        }

        // zero out the entire address space
        bzero(kernel->machine->mainMemory, MemorySize);
     */
}

//----------------------------------------------------------------------
// AddrSpace::~AddrSpace
// 	Dealloate an address space.
//----------------------------------------------------------------------

AddrSpace::~AddrSpace()
{
    /* delete pageTable; */
    // release frame table by page table
    kernel->frameTable->Release(pageTable, numPages);
}


//----------------------------------------------------------------------
// 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)
{
    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;
    // 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
#endif
    numPages = divRoundUp(size, PageSize);
    size = numPages * PageSize;

    pageTable = kernel->frameTable->Allocate(numPages);
    if (!pageTable) {
        kernel->interrupt->setStatus(SystemMode);
        ExceptionHandler(MemoryLimitException);
        kernel->interrupt->setStatus(UserMode);
    }

    DEBUG(dbgAddr, "Initializing address space: " << numPages << ", " << size);

    // then, copy in the code and data segments into memory
    uint paddr; // physical address
    ExceptionType ex; // occurring exception
    int sz, // total size to load
        vaddr, // base virtual address
        fpos, // base file position
        to_load; // size to load on each time

    if (noffH.code.size > 0) {
        DEBUG(dbgAddr, "Initializing code segment.");
        DEBUG(dbgAddr, noffH.code.virtualAddr << ", " << noffH.code.size);

        sz = noffH.code.size;
        vaddr = noffH.code.virtualAddr;
        fpos = noffH.code.inFileAddr;

        for (uint offset = 0; offset < sz; offset += PageSize) {
            ex = Translate(vaddr + offset, &paddr, 1);

            if (ex != NoException) {
                kernel->interrupt->setStatus(SystemMode);
                ExceptionHandler(ex);
                kernel->interrupt->setStatus(UserMode);
            }

            to_load = offset + PageSize < sz ? PageSize : sz - offset;

            executable->ReadAt(
                &(kernel->machine->mainMemory[paddr]),
                to_load, fpos + offset);
        }
    }

    if (noffH.initData.size > 0) {
        DEBUG(dbgAddr, "Initializing data segment.");
        DEBUG(dbgAddr, noffH.initData.virtualAddr << ", " << noffH.initData.size);

        sz = noffH.initData.size;
        vaddr = noffH.initData.virtualAddr;
        fpos = noffH.initData.inFileAddr;

        for (uint offset = 0; offset < sz; offset += PageSize) {
            ex = Translate(vaddr + offset, &paddr, 1);

            if (ex != NoException) {
                kernel->interrupt->setStatus(SystemMode);
                ExceptionHandler(ex);
                kernel->interrupt->setStatus(UserMode);
            }

            to_load = offset + PageSize < sz ? PageSize : sz - offset;

            executable->ReadAt(
                &(kernel->machine->mainMemory[paddr]),
                to_load, fpos + offset);
        }
    }

#ifdef RDATA
    if (noffH.readonlyData.size > 0) {
        DEBUG(dbgAddr, "Initializing read only data segment.");
        DEBUG(dbgAddr, noffH.readonlyData.virtualAddr << ", " << noffH.readonlyData.size);

        sz = noffH.readonlyData.size;
        vaddr = noffH.readonlyData.virtualAddr;
        fpos = noffH.readonlyData.inFileAddr;

        // read only flag for page table
        for (int i = 0, lim = divRoundUp(sz, PageSize),
            from = vaddr / PageSize; i < lim; ++i)
            pageTable[from + i].readOnly = TRUE;

        for (uint offset = 0; offset < sz; offset += PageSize) {
            ex = Translate(vaddr + offset, &paddr, 0); // read only

            if (ex != NoException) {
                kernel->interrupt->setStatus(SystemMode);
                ExceptionHandler(ex);
                kernel->interrupt->setStatus(UserMode);
            }

            to_load = offset + PageSize < sz ? PageSize : sz - offset;

            executable->ReadAt(
                &(kernel->machine->mainMemory[paddr]),
                to_load, fpos + offset);
        }
    }
#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)
{

    kernel->currentThread->space = this;

    this->InitRegisters();		// set the initial register values
    this->RestoreState();		// load page table register

    kernel->machine->Run();		// jump to the user program

    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 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;
}

FrameTable::FrameTable() {
    for (int i = 0; i < NumPhysPages; ++i)
        available.Append(i);
}

FrameTable::~FrameTable() {}

uint FrameTable::RemainSize() { return available.NumInList(); }

PageTable FrameTable::Allocate(uint pageNum) {
    // if not enough memory
    if (RemainSize() < pageNum)
        return NULL;

    PageTable ptb = new TranslationEntry[pageNum];

    for (int i = 0; i < pageNum; ++i) {
        ptb[i].virtualPage = i;
        int f = available.RemoveFront(); // frame number
        ptb[i].physicalPage = f;
        // initialize flags
        ptb[i].valid = TRUE;
        ptb[i].use = FALSE;
        ptb[i].dirty = FALSE;
        ptb[i].readOnly = FALSE;
        // zero out the entire address space
        bzero(kernel->machine->mainMemory + f * PageSize, PageSize);
    }
    return ptb;
}

void FrameTable::Release(PageTable ptb, int pageNum) {
    if (!ptb)
        return; // nothing to release
    for (int i = 0; i < pageNum; ++i)
        available.Append(ptb[i].physicalPage);
    delete[] ptb;
}