GENERAL TIPS:

Put checks everywhere! Just because a Syscall routine gets a file ID doesn't mean the file exists. Also use ASSERTs to verify that what you think must be true is. Both of these techniques help you narrow where problems exist.

Test your code as you go along. Make up your own test cases for debug. Put debug print statements in the nacho code (exception.cc mostly) to see intermediate values because the user code is highly restricted in what it can use for IO (which is basically the console, but you can't use the console for debug until you've debugged the code).

Code for any of these routines should not exceed 25 or so lines (except for ExceptionHandler()) and many routines can be done in a dozen lines.  If you are greatly exceeding this metric then you are probably doing something wrong.  However, if you put a lot of checks and printouts then you will may have more.

Get started SOON, or better yet, NOW!  Too many people waited too long before they started lab 2.  Do not make that mistake here. There will be NO extensions and late penalties will apply.
 

You need to Implement some of the System Calls

• there are 6 system calls that you must implement for the first part of this assignment
• you can find routines Halt, Create, Open, Read, Write, Close, Exit and Length prototyped in syscall.h
• somewhat unexpectedly, you will be implementing them in exception.cc (not syscall.cc)

1. SyscallCreate
2. SyscallOpen
3. SyscallClose
4. SyscallRead
5. SyscallWrite
6. SyscallLength

Getting Started with the Syscall Implementations...

• read syscall.h comments closely (they give a good idea of what needs to be done)

• in test/halt.c, a call to Halt() will make a call to ExceptionHandler(int which)
• passing an integer with the value SC_Halt

• SyscallCreate, SyscallOpen, SyscallRead, etc. will be called by the ExceptionHandler() case that they correspond to

Tips for Create()

• SyscallCreate is a wrapper around the call of Create from the global variable file System (defined in system.cc)
• you have to pass a name to the fileSystem->Create() method
• since the call is in KERNEL space, but the pointer is in USER space you must first create a copy of the name by allocating storage for, and copying the text
• this buffers kernel calls from user space for protection
• ALL data transferred between USER/KERNEL or KERNEL/USER *MUST* be copied
• things may work if you don't but you will lose points for ignoring protection
• see the routine UserToKernelString(name) in exception.cc
• delete this storage when done
• this basic process is used in most of the SyscallXXX routines

• you must increment the PC before returning

Tips for Close()

close() finds a file by ID and removes it from the list of files

• use files->SortedRemove(id) to get your Openfile*
• remove the file
• don't forget to check if the ID is valid

Tips for Read()

• follow the tips for Write()
• console input ID is ALWAYS ConsoleInput, (0) and is equivalent to STDIN in Unix

Tips for Open()

opens a file if it exists, or, if it doesn't, creates it and then opens it

• check that the maximum number of open files allowed are not already open
• use fileSystem calls (i.e., fileSystem->Open) to get the OpenFile*
• you have to assign a unique ID to the file which gets saved with the file ptr on your file list
• this ID is also returned to the user by the function at the end
• one way of generating an ID is to have a routine that takes a start value that gets set to one more than the maximum ID currently in the list of open files
• an open file is then added to the file list
files->SortedInsert(openFile, id)

Tips for Write()

• writing to a console is different than writing to a file
• the console output ID is ALWAYS ConsoleOutput, (1)
• the equivalent in Unix is STDOUT
• this can be skipped until you implement a console, but be aware of the difference

• non-console file write is done via the OpenFile routine Write
• you have to find the openfile pointer by ID and pass along the data buffer and size
• Remember, the buffer pointer parameter points to USER space

Tips for Length()

I think you can figure this one out by yourselves.
 

Tips for SyscallHalt()

• should halt the system using interrupt->Halt()

• all non SyscallExceptions should call SyscallExit(-1)
• the code is simple in Lab 3
• Lab 4 with Multitasking will require more work on these

Tips for SyscallExit()

• much like Halt, but you must close all opened files first
• put the code in to loop through open files and calling SyscallClose()
• Since you will only have one thread call SyscallHalt() as the last instruction in SyscallExit()
• You will modify this in lab 4
• the integer parameter process_status is used in lab 4 so you don't do anything with it for now

PASSING ARGUMENTS TO SYSCALLS IS TRICKY!

Values are passed to the ExceptionHandler via registers as integers. You must cast the register values to the appropriate types in your SyscallXXX invocations.

RETURNING A VALUE IS TRICKY!

The kernel is communicating with the user process via machine registers. See the top comments in exception.cc that states values are returned in reg 2. Read up in machine.cc on ReadRegister and WriteRegister. Register read and write examples are in the shell code of exception.cc.
 

void ExceptionHandler(ExceptionType which)

The system call exceptions are caught by ExceptionHandler which calls the proper syscall handlers

• use a switch statement to handle which type of exception has happened
• the kind of possible exceptions are listed as an enum ExceptionType in machine.h
• don't forget a case to handle if the Exception is not one of the allowed types

• for the non-syscall exceptions, just print and error and do a SyscallExit with a -1 as the parameter

• in the SyscallException you can use another switch to find the type of SyscallException (SC_Exit, SC_Create, SC_Close, etc...)
• you can get the type by setting the switch variable of the SyscallException case statement to machine->ReadRegister(2)

For more info on this read:

Salsa: System Calls and Exception Handling
Roadmap: System Calls and ExceptionHandling

Global variables in threads/system.h(.cc)

• we shall have only one process running in this lab
• you will need a global variable to keep track of open files for the process (i.e.  create a global List *files)
• this should be a pointer to a list class where open files get added and from which closed files will be deleted
• call new and delete at the appropriate places

Console

• you will need a global Console structure (see machine/console.h)
• this is the standard input/output device which is your screen
• look at machine/console.cc
• trick is to make sure characters are ready before you can read them and the device is not busy before you can write them. Basically you have to synchronize to the console

I hope this sounds familiar to the producer/consumer problem of lab 2.

Sample TestCases

Write VERY simple test codes to generate some of the exceptions: divide by zero (watch out, compiler tries to optimize constants), over/underflow, etc.

/* test_DivideByZero.c such that compiler does not detect the error */
int main() {
    int a;
    int b;
    int c;

    a = 7;
    c = a*a;
    b = (a*a)/(a*a - c);

  /* not reached */
}

ISSUE:   Nachos does not support printf and many other standard C library functions in user programs (e.g., test/halt.c, test/test_DivideByZero.c).  The functions that are supported are in machine/sysdep.h(.cc).  This means you won't have the full arsenal of
C routines to debug your user programs.  On the other hand, the programs should be very simple.

Additional info about running user programs can be found.

Errata in the Given Code

Use the following code for UserToKernel and KernelToUser. The distributed code uses ReadMem/WriteMem, but they appear to have problems. The other method (also given in the distribution but commented out) works. Comment/Uncomment appropriately.

//-----------------------------------------------------------
// UserToKernel
//      Copies a buffer of length from user virtual address to a kernel
//      structure.
//-----------------------------------------------------------

char *UserToKernel(char *source, int length)
{
  int current=0;
  int phyAddr;
  char *dest;

  if(!source)
    return (int)0;
  dest=new char[length];
  while(current<length){
    phyAddr=GetPhysAddrInKernel((int)source++, FALSE);
    if(!phyAddr)
      return 0;
    dest[current++]=machine->mainMemory[phyAddr];
  }
  return dest;
}

//-------------------------------------------------------
// KernelToUser
//      Copies a buffer of length from kernel space to user space
//-------------------------------------------------------

void KernelToUser(char *dest, char *source, int length)
{
  int current=0;
  int phyAddr;

  while(current<length){
    phyAddr=GetPhysAddrInKernel((int)dest++, TRUE);
    // dest won't get deleted if address is invalid
    machine->mainMemory[phyAddr]=source[current++];
  }
}