Chapter 2: Operating-System Structures

1. Chapter 2: Operating-System Structures • Yang, 2012 • Partially based on • the OSCE text book

2. Chapter 2: Operating-System Structures • Operating System Services & User OS Interface • System Calls • System Programs (System utilities) • Operating System Design and Implementation • Virtual Machines

3. A View of Operating System Services

4. Linux Layers

5. Nachos system Layers Projects 2&3 User process User process Nachos kernel threads Thread 1 Thread 2 Thread N Project 1 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)

6. OS UI: Shell Command Interpreter

7. OS User Interface: GUI

8. Programming API – OS System Call

9. Standard C Library Example • C program invoking printf() library call, which calls write() system call

10. System Calls • System calls: Programming interface to the services provided by the OS • Mostly accessed by programs via a high-level 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?

11. System Calls • System calls: Programming interface to the services provided by the OS • Mostly accessed by programs via a high-level 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.

12. Types of System Calls • Process control • File management • Device management • Information maintenance • Communications • Protection

13. Examples of Windows and Unix System Calls

14. Transition from User to Kernel Mode

15. Unix I/O Calls • fileHandle = open(pathName, flags) • A file handle is a small integer, valid only within a single process, to operate on the device or file • Pathname: a name in the file system. In unix, devices are put under /dev. E.g. /dev/ttya is the first serial port, /dev/sda the first SCSI drive • Flags: read only, read/write, append etc… • Mode may be added as the third argument for file permission • errorCode = close(fileHandle) • Kernel will free the data structures associated

16. 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. Bytes placed from 0th byte. • 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

17. 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; }

18. 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); }

19. 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

20. Linux Utility Programs

21. 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

22. OS Design Principles • Separate policy (what to do) and mechanism (how to do) • Why? • Layered structure • Modular • Monolithic kernel vs. Microkernel Maximize flexibility

23. 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.

24. MS-DOS: Simple Layer Structure • written to provide the most functionality in the least space

25. Traditional UNIX System Structure

26. 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

27. Monolithic Kernel vs. Microkernel

28. 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

29. Mac OS X Structure

30. Virtual Machines • A virtual machinetakes the layered approach • A virtual machine provides an interface identical to the underlying bare hardware. • The hostcreates the illusion that each guest has its own processor and virtual memory/storage.

31. Virtual Machines (Cont.) (a) Non-virtual machine (b) virtual machine

32. VMware Architecture

33. The Java Virtual Machine

34. New OS Interface for Applications

35. Android (Linux-based)

36. Apple iOS Unix-based