Download Replication, Load-balancing, and QoS

Lecture 2: OS Programming
Interface
T. Yang, CS 170 2015
Operating System Concepts – 8th Edition
Silberschatz, Galvin and Gagne ©2009
What to Learn?

Operating System Services & Interface




System Calls
System utilities
OS Layers
Virtual Machines
A View of Operating System Services
Role of system calls
Compilers
Word Processing
Web Browsers
Email
Databases
Web Servers
Portable OS Library
User
Application / Service
OS
System Call
Interface
System
Portable OS Kernel
Software
Platform support, Device Drivers
Hardware
x86
Ethernet
PowerPC
ARM
PCI
802.11 a/b/g/n SCSI IDE Graphics
Linux Layers
Nachos system Layers
User process
User process
Projects 2&3
Project 11
Thread
Nachos kernel threads
Thread 2
Thread N
Nachos OS modules
(Threads mgm, File System, Code execution/memory mapping,
System calls/Interrupt)
Simulated MIPS Machine
(CPU, Memory, Disk, Console)
Base Operating System
(Linux for our class)
OS UI: Shell Command Interpreter
OS User Interface: GUI
Programming API – OS System Call
Standard C Library Example

C program invoking printf() library call,
which calls write() system call
User mode
Kernel mode
System Calls


System calls: Programming interface to the
services provided by the OS
Mostly accessed by programs via a highlevel Application Program Interface
(API) rather than direct system call use

Three most common APIs are




Win32 API for Windows,
POSIX API for POSIX-based systems (including
virtually all versions of UNIX, Linux, and Mac OS X),
and
Java API for the Java virtual machine (JVM)
Why use APIs rather than system calls?
System Calls


System calls: Programming interface to the
services provided by the OS
Mostly accessed by programs via a highlevel Application Program Interface
(API) rather than direct system call use

Three most common APIs are




Win32 API for Windows,
POSIX API for POSIX-based systems (including
virtually all versions of UNIX, Linux, and Mac OS X),
and
Java API for the Java virtual machine (JVM)
Why use APIs rather than system calls?
Portability. Simplicity.
Types of System Calls






Process control
File management
Device management
Information maintenance
Communications
Protection
Examples of Windows and
Unix System Calls
Transition from User to Kernel Mode
I/O & Storage Layers
Application / Service
High Level I/O
Low Level I/O
Syscall
File System
I/O Driver
streams
handles
registers
descriptors
Commands and Data Transfers
Disks, Flash, Controllers, DMA
Unix I/O Calls

fileHandle




= open(pathName, flags)
A file handle (called file descriptor in Unix) is a
small integer, pointing to a meta data structure
about this file.
Pathname: a name in the file system.
Flags: read only, read/write, append etc…
errorCode = close(fileHandle)

Kernel will free the data structures associated
Unix I/O Calls

byteCount = read(fileHandle, buf, count)




Read at most count bytes from the device and put
them in the byte buffer buf.
Kernel can give the process fewer bytes, user
process must check the byteCount to see how
many were actually returned.
A negative byteCount signals an error (value is the
error type)
byteCount = write(fileHandle, buf, count)



Write at most count bytes from the buffer buf
Actual number written returned in byteCount
A negative byteCount signals an error
Copy file1 to file2
#command syntax: copy file1 file2
#include <stdio.h>
#include <fcntl.h>
#define BUF_SIZE 8192
void main(int argc, char* argv[]) {
int input_fd, output_fd;
int ret_in, ret_out;
char buffer[BUF_SIZE];
/* Create input file descriptor */
input_fd = open (argv [1], O_RDONLY);
if (input_fd == -1) {
printf ("Error in openning the input file\n"); return;
}
19
copy file1 file2
/* Create output file descriptor */
output_fd = open(argv[2], O_WRONLY | O_CREAT, 0644);
if(output_fd == -1){
printf ("Error in openning the output file\n"); return;
}
/* Copy process */
while((ret_in = read (input_fd, &buffer, BUF_SIZE)) > 0){
ret_out = write (output_fd, &buffer, ret_in);
if(ret_out != ret_in){ /* Write error */
printf("Error in writing\n");
}
}
close (input_fd); close (output_fd);
}
20
Shell

A shell is a job control system



Proj 0
Lets user execute system utilities/applications
Windows, MacOS, Linux all have shells
Typical format:



cmd arg1 arg2 ... argn
i/o redirection <, >
filters & pipes
 ls | more
System Programs/Utilities

Categories of System programs/utilities








Process status and management
File /directory manipulation
File modification and text processing
Programming language support (compilers)
Program loading and execution
Communications
Application programs
Most users’ view of the operation system is
defined by system programs, not the
actual system calls
Linux Utility Programs
OS Design & Implementation

Start by defining goals and specifications

Affected by
 Choice of hardware
 User goals –


convenient to use, easy to learn,
reliable, safe, and fast
System goals –

easy to design, implement, and
maintain, as well as flexible, reliable,
error-free, and efficient
OS Design Principles

Separate policy (what to do) and
mechanism (how to do)




Why?
Maximize flexibility
Layered structure
Modular
Monolithic kernel vs. Microkernel
Layered Approach

The operating system is divided into a
number of layers (levels), each built on top
of lower layers. The bottom layer (layer 0),
is the hardware; the highest (layer N) is the
user interface.
MS-DOS: Simple Layer Structure

written to provide the most functionality in
the least space
Traditional UNIX System Structure
Modular approach




Object-oriented
Each core component is separate
Each talks to the others over known interfaces
Each is loadable as needed within the kernel
Monolithic Kernel vs. Microkernel
30
Microkernel System Structure




Moves as much from the kernel into “user” space
Communication takes place between user modules using
message passing
Benefits:
 Easier to extend a microkernel
 Easier to port the operating system to new architectures
 More reliable (less code is running in kernel mode)
 More secure
Weakness:
 Performance overhead of user space to kernel space
communication
Mac OS X Structure
Virtual Machines



A virtual machine takes the layered
approach
A virtual machine provides an interface
identical to the underlying bare
hardware.
The host creates the illusion that each
guest has its own processor and
virtual memory/storage.
Virtual Machines (Cont.)
(a) Non-virtual machine (b) virtual machine
VMware Architecture
The Java Virtual Machine
New OS Interface for Applications
Google Android
Microsoft
Windows
Phone 7
Apple iOS
Application Store
Android Market
App
Marketplace
AppStore
User Interface
Java Application
Framework
Browser
3D Graphics
Cocoa
Webkit
Silverlight
Internet
Explorer
OpenGL
DirectX
OpenGL
Main programming
language
Java
C#
Objective-C
Virtual machine
CLR
None
Dalvik VM
Webkit
Android (Linux-based)
Apple iOS
Unix-based
What we have learned?

Operating System Services & Interface



System Calls
System utilities
OS Layers and Virtual Machines: Discuss later
Role of system calls and utilities
Compilers
Word Processing
Web Browsers
Email
Databases
Web Servers
System utilities
Portable OS Library
User
Application / Service
OS
System Call
Interface
System
Portable OS Kernel
Software
Platform support, Device Drivers
Hardware
x86
Ethernet
PowerPC
ARM
PCI
802.11 a/b/g/n SCSI IDE Graphics