System Calls Power Point

Published on July 2016 | Categories: Documents | Downloads: 29 | Comments: 0 | Views: 201
of x
Download PDF   Embed   Report

Comments

Content

The interface between the operating system and the user programs is defined by the set of system calls that the operating system provides.

- operating system have system calls for reading files

- UNIX has rea syste calls ith three ara eters: e t s ecify the file, e t tell here the ata are t e t, a et tell how ma y ites to rea

cout = read(fd , buffer ,nbytes);

Return to Caller Trap to the Kernel
Put the code for read in register

Library procedure read

Increment SP User Space Call read Push fd Push & Buffer Push nbytes User program calling read

Kernel Space

Dispatch

Sys Call handler

CALL pid = fork () pid = waitpid (pid, &statloc, options) s = execve (name, argv, environp) exit (status)

DESCRIPTION Create a child process identical to the prevent Wait for a child to terminate Replace a process core image Terminate process executionand return status

Is the only way to create a new process in UNI . Creates an exact duplicate of the original process, including all files descriptors, registers everything.

After the fork, the original process and the copy (the parent and child) go their separate ways. All the variables have identical values at the time of the fork, but since the parent s data are copied to create the child, subsequent changes in one of them do not affect the other one. The fork call returns a value, which is zero in the child and equal to the child s process identifier or PID in the parent.

In most cases, after a fork; the child will need to execute different code from the parent. Consider the case of the shell. It reads a command from the terminal, fork of a child process, which for the child to execute the command and then reads the next command when the child terminates. To wait for the child to finish, the parent executes a waitpid system call.

HOW FORK IS BEING USED BY THE SHELL?

When command is typed, the shell forks off a new process. This child process must execute the user command. It does this by using the execve system call, which causes its entire core image to be replaced by the file named in its parameter.

#define TRUE 1 while (TRUE) { type_prompt(); read_command(command,, parameters); if (fork() !=0) { /*Parent code. */ waitpid(-1, &status, 0); } else { /*Child code. */ execve(command, parameters, 0); } } /* repeat forever */ /* display prompt on the screen */ /* read input from terminal */ /* fork off child process */ /* wait for child to exit */

/* execute command */

1. The name of the file to be executed 2. A pointer to the argument array 3. A pointer to the environment array

EXAMPLE:

main(argc, argv, envp)

1. The Text Segment 2. The Data Segment 3. The Stack Segment

STACK Unused address space

Address (hex) FFFF

GAP
DATA TEXT

0000

CALL fd = open(file, how, ) s = close(fd) n = read(fd, buffer, nbytes) n = write(fd, buffer, nbytes) position = lseek(fd, offset, whence) s = stat(name, &buf)

DESCRIPTION Open a file for reading, writing or both Close an open file Read a data from a file into a buffer Write data from a buffer into a file Move the file pointer Get a file s status information

To read or write a file, the file must first be opened using OPEN. This call specifies the file name to be opened, either as an absolute path name or relative to the working directory, and a code of O_RDONLY, O_WRONLY, or O_RDWR, meaning open for reading, writing or both.

The most heavily used calls are undoubtedly read and write. We saw read earlier. Write has the same parameters.

Lseek call changes the value of the position pointer, so that subsequent calls to read or write can begin anywhere in the file.

1. File descriptor for the file 2. File position 3. Tells whether the file position is relative to the beginning of the file, current position or the end of the file

CALL s = mkdir(name, mode) s = rmdir(name) s = link(name1, name2) s = unlink(name)

DESCRIPTION Create a new directory Remove an empty directory Create a new entry, name2, pointing to name1 Remove a directory entry

s = mount(special, name, Mount a file system flag) s = unmount(special) Unmount a file system

In this section we will look at some system calls that relate more to directories or the file system as a whole, rather than just to one specific file as in previous section.

mkdir
Create empty directories

rmdir
Remove empty directories

Link
Purpose is to allow the same file to appear under two or more names, often in different directories.

HOW LINK WORKS?

/usr/ast 16 Mail 81 Games 40 test /usr/ast Mail Games Test notes

31 70 59 38

/usr/jim Bin Memo f.c. prog1 /usr/jim Bin Memo f.c. prog1

16 81 40 70

31 70 59 38

Link( /usr/jim/memo , /usr/ast/note );

Mount system call
Allows two files to merge into one.

bin

dev

lib

mnt

usr

FILE SYSTEM BEFORE THE MOUNT

bin

dev

lib

usr

FILE SYSTEM AFTER THE MOUNT

A typical statement in C to perform the mount is:

mount(³/dev/fd0´, ³/mnt´, 0);
Where the 1st parameter is the name of a block special file for drive 0, the 2nd parameter tells whether the file system is to be mounted readwrite or read-only.

CALL s = chdir(dirname)

DESCRIPTION Change the working directory

s = chmod(name, mode) Change a file s protection bits s = kill(pid, signal) Send a signal to a process seconds = time(&seconds) Get the elapsed time since Jan. 1, 1970

Changes the current working directory.

After the call:

chdir(³/usr/ast/test´);
An open on the file xyz will open /usr/ast/test/xyz. The concept of a working directory eliminates the need for typing (long) absolute path names all the time.

Makes it possible to change mode of a file.

For example, to make a file read-only by everyone except the owner, one could execute

chmod(³file´, 0644);

The way users and user processes send signals.

If a process is prepared to catch a particular signal, then when it arrives, a signal handler is run. If the process is not prepared to handle a signal, then its arrival kills the process (hence the name of the call).

Just returns the current time in seconds, with corresponding to Jan. 1, 1970 at midnight (just as the day was starting, not ending)

Windows and UNI differ in a fundamental way in their respective programming models.

Consists of codes that does something or other, making system calls to have certain services performed.

Normally event driven. The main program waits for some event to happen, then calls a procedure to handle it.

Typical events are keys being struck, the mouse being moved, a mouse button being pushed, or a floppy disk inserted.

Microsoft s defined set of procedures that programmers are expected to use to get operating system services.

THE BIG MESS

The structure is that there is no structure. The operating system is written as a collection of procedures, each of which can call any of the other ones whenever it needs to.

Main Procedure

Service Procedure

Utility Procedure

A generalization is the approach of monolithic system structure is to organize the operating system as a hierarchy of layers, each one constructed upon the one below it.

The first system constructed in these way was the THE system built at the Technische Hogesehool Eindhove in the netherlands. The THE system was a simple batch system for a Dutch computer.

LAYER 5 4 3 2 1 0

FUNCTION The operator User programs Input/Output management Operator-process Communication Memory and drum Management Processor allocation and multiprogramming

STRUCTURE OF THE OS

Described as having a series of concentric rings, with the inner ones being more privileged than the outer ones (which is effectively the same thing).

This system, originally called CP/CMS and later renamed VM/370 (Seawright and MacKinnon, 1979) was based on an astute observation: a timesharing system provides

1. Multiprogramming 2. An extended machine with no more convenient interface than the bare hardware

Heart of the system, runs on the bare hardware and does the multiprogramming, providing not one, but several virtual machines to the next layer up.

Unlike all other OS, these Virtual machines are not extended machines, with files an other nice features. Instead, they are EXACT copies of the bare hardware, including kernel/user mode, I/O,, interrups, and everything else the real machine has.

Virtual 370

System calls here
I/O Instructions here Trap here CMS CMS CMS

Trap here

VM/370 370 Bare Hardware

STRUCTURE FOR VM/370 with CMS

A program at the bottom layer, running in kernel mode.

Its job is to allocate resources to virtual machines and then check attemps to use them to make sure no machine is trying to use somebody else s resources.

Client process

Client process

Process Server

Terminal Server

...

File Server

Memory Server

User mode

Microkernel

Kernel mode

The client server model

Machine 1

Machine 2

Machine 3
Process Server

Machine 4
Terminal Server

Client

File Server Kernel

...

Kernel

Kernel

Kernel

...

Message from client from to server

The server- client model in a distributed system

Sponsor Documents

Or use your account on DocShare.tips

Hide

Forgot your password?

Or register your new account on DocShare.tips

Hide

Lost your password? Please enter your email address. You will receive a link to create a new password.

Back to log-in

Close