System Calls讲解、辅导C/C++语言、讲解Software、辅导C/C++程序

Nachos Project 2 Part 2: System Calls

Due date: 11:59 PM, December 6, 2018. Your required part must

be submitted on time (by December 6th) and work properly before

you can attempt the bonus part. The usual two-day grace period

applies. However, we will not accept any submissions after the

grace period (i.e., midnight Sunday). Note that you have two

submission sites: the required and bonus sites.

1 A few more words on submissions

As mentioned above, your required part must be submitted on time (by December 6th) and work

properly before you can attempt the bonus part. The usual two day grace period applies. However,

we will not accept any submissions after the grace period (i.e., midnight Sunday). Therefore, your

options are: (1) attempt only the required part and submit it within the grace period; and (2)

finish the required part and submit it by December 6th and finish and submit the bonus part by

the grace period.

Note that you have two submission sites: the required and bonus sites.

2 An Important Reminder

It is a good time to review the academic integrity policy of the university (http://class.syr.

edu/academic-integrity) and the course honor pledge you submitted at the beginning of the

semester. For this programming project (Part 1 and Part 2), we will use moss (https://theory.

stanford.edu/~aiken/moss/), A System for Detecting Software Similarity, extensively to detect

plagiarism among your program submissions. Please remember that violating academic integrity

policy will greatly jeopardize your grade as you agreed on the honor pledge.

1

3 Overview

This part of Project 2 is 60 points with an additional 25 points of bonus. You need to implement

the following system calls:

Written Part (required: 15 points): This written part is to read and understand addrspace.[cc|h]

and other related files such as machine/machine.[cc|h]. Refer back to Part 1. When you run

Nachos with ./nachos -quantum <quantum size> -x ../test/prog1 -x ../test/prog2,

prog1 and prog2 are loaded in the main memory, which is an array of characters defined

in machine/machine.[cc|h]. addrspace.[cc|h] creates an address space for each of prog1

and prog2. The main memory is divided into page frames as you know. The size of a page

frame is the same as PageSize.

1. (2 points) How big is the main memory in KB (i.e., kibibytes)?

2. (2 points) How big is one page size and how many page frames are there in the main

memory?

3. (7 points) Modify addrspace.[cc|h] so that it will printout which virtual pages are

loaded in which corresponding page frames for prog1 and prog2. For example, output

should look like:

[Your SUID, Name] Page Frame 0 contains Page 0 of Program ../test/prog1

[Your SUID, Name] Page Frame 1 contains Page 1 of Program ../test/prog1

etc..

4. (2 points) For prog1, how big is the uninitialized data segment size? Can you tell this

by just analyzing the source code, prog1.c? If so, how?

5. (2 points) For prog2, which page frames contain the code segments?

What to submit: a document that contains your answers to the questions and the screenshot

of the program output for Question 3.

Write() (required: 15 points): a system call that uses printf to print characters to screen.

Note that using printf directly instead of going through console.[cc|h] is sort of faking it

to make the implementation of this part easy.

Exec() (required: 15 points; bonus: 10 points): a combination of the fork() and

exec() UNIX system calls that creates process to run user program.

Join() (bonus: 10 points): similar to the waitpid() UNIX system call that blocks the

calling process to wait for another process.

2

Exit() (required: 15 points; bonus: 5 points): required implementation requires a

single Thread::Finish() call, bonus implementation is similar to the exit() UNIX system

call that wakes up any waiting process.

There are three testing user programs, prog3.c, prog3b.c and prog4.c. prog3 is for testing

the required part, prog3b is for testing the bonus part, and prog4 is called by the other two and

is not intend to be executed directly.

4 Requirements

1. Write() system call writes string to a specified destination. In this project we’re faking it

using printf, therefore it always writes to the screen. The system call takes three arguments:

a char* buffer, an int size, and an OpenFileId. Since we’re faking it and not utilizing

the Nachos file system, we can ignore the OpenFileId parameter. You need to obtain the first

two arguments from the user program (see 5 below) and print an character at a time using

printf. Refer to the comments in exception.cc for hints on how to obtain the parameter

values.

2. Exec() takes one string argument that is the file name of a user program. The way Exec()

creates threads is similar to what you did for the -x flag in Part 1. When a user program

calls Exec(), Nachos kernel creates a new thread for the executable file name given as the

argument for Exec(). Nachos creates address space, initializes states and registers, and jumps

to user level, as is done in RunUserProg(). For the bonus, Exec() also needs to return a

SpaceId (defined in syscall.h) of the new thread, which can be used as the argument of

Join(). See the source code of the test programs for the usage and refer to the comments in

exception.cc for hints on how to return a value from system call.

3. Join() (bonus) takes one argument that is the SpaceId of the joined thread. SpaceId is

an integer, you can use it as a pointer to a corresponding kernel thread, or as an index to a

kernel thread table. Either way, the caller (joining thread) needs to be associated with the

joined thread so that the joined thread can wake it up later. Then the joining thread calls

Thread::Sleep() to get blocked.

4. For the required part, Exit() can be implemented with a simple call to Thread::Finish().

For the bonus, Exit() is where a joined thread wakes up its joining threads. This is possible

because in Join(), the joining threads are already associated with the joined thread using

either a pointer or an index. Now the caller (joined thread) can wake up the joining threads

using Scheduler::ReadyToRun().

3

5. You can use Machine::ReadRegister() to read registers, Machine::WriteRegister() to

write registers, and Machine::ReadMem() to read from a virtual memory address. Note that

Machine::ReadMem() performs virtual to physical translation using Machine::Translate().

5 Tests and Output

The required part is tested with the command “./nachos -x ../test/prog3”. The output should

be:

Hello from prog3

Hello from prog4

The bonus part is tested with the command “./nachos -x ../test/prog3b”. The output should

be:

Hello from prog4

Hello from prog3b

6 What to Submit

For the written part, a document that contains your answers to the questions and the screenshot

of the program output for Question 3. The project is due by the end of Thursday, December 6,

2018. Please compress your whole os folder and a screenshot of your output, name the compressed

file LastName,FirstName.zip (NOTE: .zip ONLY!) and submit it on Blackboard.