Nachos Instructional OS: Part 2

Nachos Instructional OS: Part 2

CS 170, Tao Yang, Fall 2012

04/21/23 2

What to learn? How to execute a program in Nachos

Produce binary MIPS code from a C program Execute this MIPS code in a tiny space Make a simple Nachos system call in a C

program Project 2.

Support the execution of multiple processes Support multiprogramming.

System calls for process execution. System calls for a simple file system interface.

System Layers

Base Operating System (Linux for our class)

Nachos kernel threads

Thread 1 Thread 2 Thread N

Nachos OS modules(Threads mgm, File System, Code execution/memory mapping,

System calls/Interrupt)

MIPS Virtual Machine(Memory, Disk, Console)

User process:Binary code

User process:Binary code

Machineobject

SP

Rn

PC

memory

page table

04/21/23 4

Virtual Machine Layer

under machine subdirectory. Approximates the MIPS architecture

Can execute a sequence of MIPS instructions.

registers

Timer

04/21/23 5

Two modes of executions User mode: execute instructions which only

access the user space. Kernel mode kernel executes when Nachos first starts up or when an instruction causes a trap

illegal instruction, page fault system call

Nachos layer

04/21/23 6

Code execution steps in Nachos Load instructions into the machine's memory. Initialize registers (program counter, etc). Tell the machine to start executing

instructions. The machine fetches the instruction, decodes

it, and executes it. Repeat until all instructions are executed.Handle interrupt/page fault when needed

NachosNachos execution layer

MIPS Machine

User binary code

04/21/23 7

Machine Object: Implement a MIPS machine

an instance created when Nachos starts up. Supported public variables:

Registers: 40 registers. 4KB Memory: Byte-addressable. 32 pages

(128Bytes) Virtual memory: use a single linear page

table or a software-managed TLB.

Machineobject

SP

Rn

PC

memory

page table

04/21/23 8

Code/machine/machine.h

class Machine {char *mainMemory; // physical memory to store user

program, // code and data, while executing

int registers[NumTotalRegs]; // CPU registers, for executing user programs

TranslationEntry *pageTable;

unsigned int pageTableSize;

04/21/23 9

Machine Object: Supported operations

Machine(bool debug);//allocate memory of 32 pages (128bytes per page). Initialize memory/register/ page table

Translate(int virtAddr, int* physAddr, int size, bool writing);

OneInstruction(); // Run one instruction of a user program.

Run(); // Run a user program ReadRegister(int num); WriteRegister(int num, int value); ReadMem(int addr, int size, int* value); WriteMem(int addr, int size, int value);

04/21/23 10

Code/machine/ipssim.ccvoid Machine::Run(){

Instruction *instr = new Instruction; // storage for decoded instruction

interrupt->setStatus(UserMode);

for (;;) { OneInstruction(instr); //fetch and execute one instructioninterrupt->OneTick(); //advance clock

}}

11

Code/machine/machine.hclass Instruction { public: void Decode(); // decode binary representation of instruction

unsigned int value; // binary representation of the instruction

unsigned char opCode; // Type of instruction

unsigned char rs, rt, rd; // Three registers from instruction.

int extra; // offset or other purpose. Treat as 0};

12

Code/machine/ipssim.ccVoid Machine::OneInstruction(Instruction *instr) {

//Fetch an instruction and then decodeif (!machine->ReadMem(registers[PCReg], 4, &raw)) return; //if error, returninstr->value = raw; instr->Decode();// Execute the instruction switch (instr->opCode) {

…case OP_ADDU: registers[instr->rd] = registers[instr->rs] + registers[instr->rt];break;case OP_SW: machine->WriteMem(registers[instr->rs], 4, registers[instr->rt]); break;…case OP_SYSCALL: RaiseException(SyscallException, 0); return;…

}// Advance program counters.registers[PCReg] = registers[NextPCReg]; registers[NextPCReg] = pcAfter; //which is registers[NextPCReg] + 4;}

13

Code/machine/translate.ccbool Machine::WriteMem(int addr, int size, int value) { ExceptionType exception; int physicalAddress;

exception = Translate(addr, &physicalAddress, size, TRUE);//address translation if (exception != NoException) { machine->RaiseException(exception, addr); return FALSE; }

switch (size) { //Copy value to the target physical memory address properlycase 1: machine->mainMemory[physicalAddress] = (unsigned char)

(value & 0xff); break; case 2: *(unsigned short *) &machine-

>mainMemory[physicalAddress] = ShortToMachine((unsigned short) (value & 0xffff)); break;

case 4:….

}}bool Machine::ReadMem(int addr, int size, int *value) {…}

A Simple Page Table

PFN 0PFN 1

PFN i

page #i offset

user virtual address

PFN i+

offset

process page table

physical memorypage frames

Each process has its own page table. Virtual addresses are

translated relative to the current page table.

ExceptionType Machine::Translate(int virtAddr, * physAddr, size, writing) {unsigned int vpn, offset; TranslationEntry *entry; unsigned int pageFrame;

// calculate virtual page number, and offset within the page vpn = (unsigned) virtAddr / PageSize; offset = (unsigned) virtAddr % PageSize;

entry = &pageTable[vpn];pageFrame = entry->physicalPage;

entry->use = TRUE; // set the use, dirty bits if (writing) entry->dirty = TRUE;

*physAddr = pageFrame * PageSize + offset; // compute physical address return NoException; } 15

Code/machine/translate.cc

Physical page use bit | dirty bit

Machineobject

SP

Rn

PC

memory

page table

04/21/23 16

Virtual Machine Layer

registers

Timer

Interrupt

04/21/23 17

Interrupt Object Maintain an event queue with a simulated clock. Supported operations:

Schedule(VoidFunctionPtr handler, int arg, int when, IntType type) Schedule a future event to take place at time ``when''.

Usage: schedule a yield at random interval. SetLevel(IntStatus level). Used to temporarily disable and re-

enable interrupts. Two levels are supported: IntOn and IntOff. OneTick()—advance 1 clock tick CheckIfDue(bool advanceClock). Examines if some event

should be serviced. Idle(). ``advances'' to the clock to the time of the next

scheduled event

04/21/23 18

Interrupt::OneTick()

Software managed clock. The clock advances 1 tick for user mode, 10

for system mode after every restored interrupt

(disable/enable Interrupt) or after the MIPS simulator executes one

instruction. When the ready list is empty, fast-advance

ticks until the next scheduled event happens.

04/21/23 19

Timer object

Generate interrupts at regular or random intervals

Then Nachos invokes the predefined clock event handling procedure.

Supported operation: Timer(VoidFunctionPtr timerHandler, int callArg, bool

doRandom). Create a real-time clock that interrupts

every TimerTicks (100) time units Or set this a random number for random mode

04/21/23 20

Console Object

Simulates the behavior of a character-oriented CRT device Data can be written to the device one character at a time

through the PutChar() routine. Input characters arrive one-at-a-time. They can be

retrieved by GetChar(). Supported operations:

Console(char *readFile, char *writeFile, VoidFunctionPtr readAvail,VoidFunctionPtr writeDone, int callArg).

Create a console instance.``readFile'' is the Unix file of where the data is to be read from; if NULL, standard input is assumed.

PutChar(char ch) GetChar()

04/21/23 21

Disk Object

Simulates the behavior of a real disk. The disk has only a single platter, with multiple tracks

(32). Each track contains the same number of sectors (32). Allow only one pending operation at a time. Contain a ``track buffer'' cache. Immediately after

seeking to a new track, the disk starts reading sectors, placing them in the track buffer.

Supported operations: Disk(char *name, VoidFunctionPtr callWhenDone, int

callArg) ReadRequest(int sectorNumber, char *data) WriteRequest(int sectorNumber, char *data) ComputeLatency(int newSector, bool writing)

Executing a user program

data

user spaceMIPS instructions executed

by the emulator

Nachos

kernelMIPS emulator

halt

Machineobject

fetch/executeexamine/deposit

SaveState/RestoreStateexamine/deposit

Machine::Run()

ExceptionHandler()

SP

Rn

PC

registers memory

page table

process page tables

From C program to MIPS binary

int j;char* s = “hello\n”;

int p() { j = write(1, s, 6); return(j);}

myprogram.c

gcccompiler

…..p: store this store that push jsr _write ret etc.

myprogram.s

assembler data

myprogram.o

linker

object file

data program

(executable file)myprogram

datadatadata

libraries and

other objects

04/21/23 24

Binary code format (Noff)Source code: under userprog subdirectory. Current Nachos can run a single MIPS binary (Noff

format) type ``nachos -x ../test/halt''.

A user program must be compiled using a cross-platform gcc compiler that generates MIPS code.

A Noff-format file contains (bin/noff.h) the Noff header, describes the contents of the rest of the file executable code segment (TEXT) initialized data segment (DATA) uninitialized data segment (BSS).

Space usage during execution of a C program

STACK

HEAP

BSS

DATA

TEXT

Stack grows from top-down.

Heap grows bottom-up

Uninitialized data

Initialized data

Code

04/21/23 26

TEXT, DATA, BSS, HEAP, STACK in C

Int f3=3; /* DATA segment */Int f1; /*BSS segment*/def[] = "1"; /* DATA segment */int main(void)

{static char abc[12], /* BSS segment */static float pi = 3.14159; /* DATA segment */int i = 3; /* Stack*/char *cp; /*stack*/cp= malloc(10); /*malloc allocates space from HEAP*/f1= i+f3; /* code is in TEXT*/

strcpy(abc , "Test" ); /* “Test” is located in DATA segment */

}

04/21/23 27

Noff format. Each segment has the following

information: virtualAddr: virtual address that

segment begins at. inFileAddr: Pointer within the Noff file

where that section actually begins. The size (in bytes) of that segment.

04/21/23

size = noffH.code.size + noffH.initData.size +

noffH.uninitData.size+ UserStackSize

User process for executing a program

A Nachos thread is extended as a process Each process has its own address space containing

Executable code (Code segment) Initialized data (Data segment) Uninitialized data (BSS) Stack space for function calls/local variables

how big is address space?

A process owns some other objects, such as open file descriptors.

04/21/23 29

Steps in User process creationCurrently only execute a single user program.1. Create an address space.2. Zero out all of physical memory (machine-

>mainMemory)3. Read the binary into physical memory and initialize

data segment.4. Initialize the translation tables to do a one-to-one

mapping between virtual and physical addresses.5. Zero all registers, setting PCReg and NextPCReg to 0

and 4 respectively.6. Set the stackpointer to the largest virtual address of

the process (stack grows downward).

04/21/23 30

Key Calling graph when Nachos executes under userprog directory

main() inmain.cc

Initialize()in system.cc

StartProcess ()in progtest.cc

Space=New AddrSpace()in addrspace.cc

Space->InitRegisters()

Executable fileReadAt()

Space->RestoreState()

Machine->Run ()in mipssim.cc

Machine->WriteRegister()

Machine->OneInstruction()

Interupt->OneTick()In Interupt.cc

void StartProcess(char *filename) { OpenFile *executable; AddrSpace *space;

executable = fileSystem->Open(filename); if (executable == NULL) { printf("Unable to open file %s\n", filename); return; } space = new AddrSpace(executable); currentThread->space = space; delete executable; // close file space->InitRegisters(); space->RestoreState(); machine->Run(); ASSERT(FALSE);}

Creating a Nachos Process (code/userprog/progtest.cc)

Create an AddrSpace object, allocating physicalmemory and setting up the process page table.

Set address space of current thread/process.

Initialize registers, load pagetable, and begin execution in usermode.

Create a handle for reading text and initial data out of the executable file.

AddrSpace::AddrSpace(OpenFile *executable) { NoffHeader noffH; unsigned int i, size; executable->ReadAt((char *)&noffH, sizeof(noffH), 0);

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

pageTable = new TranslationEntry[numPages]; for (i = 0; i < numPages; i++) { pageTable[i].virtualPage = i; // for now, virtual page # = phys page # pageTable[i].physicalPage = i; pageTable[i].valid = TRUE; } ....

Creating a Nachos Address Space (code/userprog/addrspace.cc)

Read the header of binary file

Compute address space need

Setup a page table for address translation

bzero(machine->mainMemory, size);

// copy in the code and data segments into memory if (noffH.code.size > 0) { executable->ReadAt(&(machine->mainMemory[noffH.code.virtualAddr]), noffH.code.size, noffH.code.inFileAddr); }

if (noffH.initData.size > 0) { executable->ReadAt(&(machine-

>mainMemory[noffH.initData.virtualAddr]), noffH.initData.size, noffH.initData.inFileAddr); }

Initializing a Nachos Address Space

Zero out memory allocated

Copy code segment to memory

Copy initialized data segment to memory

34

Compilation of halt.c Test/halt.c:

#include "syscall.h"main() { Halt(); /* not reached */}

…Halt: addiu $2,$0,SC_Halt syscall j $31.end Halt

main:….jal Halt

…

gcc -S

start.s has system call entries.System call number is always in register 2

halt.s: ssembly code of halt.c

Test/start.s

04/21/23 35

Nachos –x halt using halt.c in test directory

Interrupt->Halt()In Interupt.cc

Machine->RaiseException(SyscallException)


ExceptionHandler(SyscallException)


04/21/23 36

Code/userprog/exception.ccExceptionType Machine::Translate(int virtAddr, * physAddr, size,

writing) {

void ExceptionHandler(ExceptionType which) { int type = machine->ReadRegister(2);

if ((which == SyscallException) && (type == SC_Halt)) {

DEBUG('a', "Shutdown, initiated by user program.\n"); interrupt->Halt(); }

}// Code Convention: // system call code -- r2 // arg1 -- r4, arg2 -- r5, arg3 -- r6, arg4 -- r7

04/21/23 37

Summary: actions of “nachos –x halt”

1. The main thread starts by running function StartProcess() in file progtest.cc. This thread is used to run halt binary.

2. StartProcess() allocates a new address space and loads the halt binary. It also initializes registers and sets up the page table.

3. Call Machine::Run() to execute the halt binary using the MIPS emulator.1. The halt binary invokes the system call Halt(), which causes a

trap back to the Nachos kernel via functions RaiseException() and ExceptionHandler().

4. The exception handler determines that a Halt() system call was requested from user mode, and it halts Nachos.

04/21/23 38

Assignment 2: Multiprogramming&System Calls

Modify source code under userprog subdirectory. ~1200 lines of code.

The crossplatform compiler is under ~cs170/gcc/. This compiler on x86 machines produces a.out with the coff

format. Use utility coff2noff (under nachos’ bin directory) to convert it

as Noff. Check the makefile under test subdirectory on how to use gcc

and coff2noff. System calls to be implemented:

Multiprogramming: Fork(), Yield(), Exit(), Exec() and Join(). File and console I/O: Creat(), Open(), Read(), Write(), and

Close(). Test program: ~cs170/sample/PROJECT2/test

Multi-Processes and the Kernel

text

data

BSS

user stack

0

data

2n-1

Nachos kernel0

2n-1

text

data

BSS

user stack

0

data

text

data

BSS

user stack

0

data

Fork or Exec

04/21/23 40

To run multiple processesNachos should Provide the physical memory management;

Fill memory with proper data, instruction. Set up an address translation table with linear

page tables; Save/restore address-space related state

during process switching (AddrSpace::SaveUserState() and AddrSpace:RestoreUserState() are called).

04/21/23 41

Assignment 2: Files involved Key files. (Red for modification/extension)

progtest.cc -- test routines to run user code. addrspace.h addrspace.cc -- create an address space and load the

program from disk. syscall.h -- the system call interface. exception.cc -- the handler for system calls and other user-level

exceptions such as page faults. filesys.h, openfile.h console.h -- interface to the Nachos file system and

console. Other related files:

bitmap.h bitmap.cc -- manipulate bitmsps (useful for keeping track of physical page frames).

translate.h, translate.cc -- translation tables. machine.h, machine.cc -- emulates main memory, processor, etc. mipsim.cc -- emulates MPIS R2/3000 instructions. console.cc -- emulates a terminal using UNIX files.

Assignment 2: Implementation Notes

Tao Yang

Part I: Multiprogramming

Fork(func) creates a new user-level (child) process, whose address space starts out as an exact copy of that of the caller (the parent),

Yield(): temporarily relinquish the CPU to another process.

Exit(int) call takes a single argument, which is an integer status value as in Unix. The currently executing process is terminated.

Exec(filename) spawns a new user-level thread (process), but creates a new address space. It should return to the parent a SpaceId.

Join(ID) call waits and returns only after a process with the specified ID has finished.

Getting Started Review start.s (under test directory) which includes

all system call stubs, following the style of Halt. Modify ExceptionHandler() in exception.cc to

include all system call entries. After each system call, increment PC registers so that

ExceptionHandler() execution flow returns back to next instruction after user’s system call place.

counter = machine->ReadRegister(PCReg); machine->WriteRegister(PrevPCReg,counter); counter = counter + 4; machine->WriteRegister(PCReg,counter); counter = counter + 4; machine->WriteRegister(NextPCReg,counter);

Arguments of a system call are in Registers 4, 5, 6 etc. how to verify? You may review MPIS assembly code produced for a

test C program using gcc with -S. If needed, return result is register 2

machine->WriteRegister(2,result);

PCB (Process Control Block)

Write the PCB and a process manager. Create a PCB class that will store the necessary information about a process. Don't worry about putting everything in it right now, you can always add more as you go along. To start, it should have a PID, parent PID, and Thread*.

The process manager- it can have getPID and clearPID methods, which return an unused process id and clear a process id respectively.

Memory Manager

Write a Memory Manager that will be used to facilitate memory allocation: Track memory page usage. Allocate a page Free a page

Modify AddrSpace:AddrSpace (addrspace.cc) to use the memory manager. Modify the page table constructors to use pages

allocated by your memory manager Create a PCB (process control block) also for

each process to include key control information.

AddSpace.cc Write a function (e.g. AddrSpace::Translate),

which converts a virtual address to a physical address. It does so by breaking the virtual address into a page table index and an offset.

Write a function( e.g. AddrSpace::ReadFile), which loads the code and data segments into the translated memory, instead of at position 0. Read data into a system buffer (diskBuffer). Copy buffered data into proper memory locations

(e.g. at machine->mainMemory[physAddr].)

How to Run User Processes Concurrently?

2n-1

text

data

BSS

user stack

0

datatext

data

BSS

user stack

0

data

text

data

BSS

user stack

0

data

0

2n-1

…Machine->run()…



Nachos Kernel Threads

Main program Forked process Forked process

49

Compilation of a fork program#include "syscall.h“FunEntry(){}

main() { Fork(FuncEntry);

Fork(FuncEntry);}

…Fork: addiu $2,$0,SC_Fork syscall j $31.end Fork…

FuncEntry:…

main:...la $4, FuncEntryjal Fork

… la $4, FuncEntry

jal Fork…

gcc -S

System call number is in register 2.Argument 1 is in register 4

Assembly code

Test/start.s

04/21/23 50

Questions on Forking a Process When to spawn a new kernel thread?

Do we directly use thread fork function to execute the binary of a child? Thread->Fork(FuncEntry, NULL)? Thread->Fork(Machine->Run, NULL)?

Who needs to set the program counter for the new process? Parent thread vs child thread?

Machine->RaiseException(SyscallException)


ExceptionHandler(SyscallException)


User Process and Nachos Kernel Threads

2n-1

0

2n-1

text

data

BSS

user stack

0

datatext

data

BSS

user stack

0

data

text

data

BSS

user stack

0

data


ForkBridge {…Machine->run()…}

ForkBridge {…Machine->run()…}

Nachos Kernel Threads

Main program Forked process Forked process

Thread fork

Implement Fork() in ExceptionHandler()

1. FuncEntry = Value of register 4 ( sys call argu)Target function to be executed in the new space.

2. Create a new kernel thread.3. Create a new AddrSpace to be a duplicate of

the CurrentThread's space and get a new PCB.

4. The current thread calls Yield() so the new thread can run.

5. The new thread runs a dummy function that creates a bridge for execution of the user function).

1. Call NewThread->Fork(ForkBridge, FuncEntry)

ForkBridge() : Key parts

Set counter = FuncEntry Initialize and restore the registers. For

example, currentThread->RestoreUserState(); currentThread->space->RestoreState(); machine->WriteRegister(PCReg, counter); machine-

>WriteRegister(PrevPCReg,counter-4); machine-

>WriteRegister(NextPCReg,counter+4); Call machine->Run() which executes the

forked user process in the desired FuncEntry address.

Implement Exec() Exec is creating a new process with new code and

data segments from a file. Allocate a new address space which fits this file.

Load data/code from an OpenFile object constructed from the filename passed in by the user.

In order to get that file name you will have to write a function that copies over the string from user space.

Allocate a new kernel thread and a PCB to execute with the above space.

Fork the new thread to run a dummy bridge function that sets the machine registers straight and runs the code

Call NewThread->Fork(ExecBridge ,NULL); The calling thread should yield to give control to the newly

spawned thread. Return the process ID that executes this binary.

ExecBridge(): Key parts

Initialize registers/restore state. (currentThread->space)->InitRegisters(); (currentThread->space)->RestoreState();

Machine->run();

System Calls for File System

For the entire system, maintain a set of objects (SysOpenFile class) representing system-wide opened files. Each file may be opened by many user

processes. Call it fileOpenTable[];

For each process, maintain a set of objects in PCB (UserOpenFile class) representing files opened by this process. Each file has filename, index to the system-wide

open table entry, and offset for the current read/write pointer

Implement create()/Open/Read/Write

Nachos already has a simple file system implemented Use FILESYS_STUB compiler directive

Directly use Linux interface filesys.cc and openfile.cc under filesys

directory.

Implement open()

Use fileSystem->Open() (nachos’open) to locate the file object.

Add the opened file object to the system-wide fileOpenTable. If it is already opened by some other user

process, just share the entry. Else insert to the local file open table in

PCB.

Implement read() Allocate an internal buffer. If Inputfile ID is ConsoleInput

Then use getchar() and save data in the internal buffer.

Read until EOF or \n. Else, find the current read offset.

Use openFile:ReadAt (defined in openfile.h) to read data (essentially use Linux read())

Copy data from the internal buffer to the destination memory location. Need to copy one by one since the address

needs to be translated one by one.

Implement write()

Allocate an internal buffer. Copy data from the source memory

location to the internal buffer. Need to copy one by one since the address

needs to be translated one by one. If Outputfile ID is ConsoleOutput

Then use printf (assuming string type). Else, find the current write offset.

Use openFile:WriteAt (defined in openfile.h) to write data to the Linux file.

Nachos Instructional OS: Part 2

Documents

Transcript of Nachos Instructional OS: Part 2