OS Generation and System Boot - SNS Courseware

1 of 26

OS Generation and System Boot

SNSCE-CSE/CS8493-OS/OS generation and System Boot

2 of 26

Operating System Design and Implementation

• Design and Implementation of OS not “solvable”, but some approaches have proven successful

• Internal structure of different Operating Systems can vary widely

• Start the design by defining goals and specifications • Affected by choice of hardware, type of system – batch,

time sharing, single user, multiuser, distributed, real-time

• Two groups in terms of defining goals: – User goals – operating system should be convenient to

use, easy to learn, reliable, safe, and fast – System goals – operating system should be easy to design,

implement, and maintain, as well as flexible, reliable, error-free, and efficient

• Specifying and designing an OS is highly creative task of software engineering


3 of 26

Mechanisms and Polices

• Important principle to separate Policy: What will be done?

Mechanism: How to do it? • Mechanisms determine how to do

something, policies decide what will be done

• The separation of policy from mechanism is a very important principle, it allows maximum flexibility if policy decisions are to be changed later (example – timer)


4 of 26

Implementation

• Much variation – Early Operating Systems were written in assembly language – Then with system programming languages like Algol, PL/1 – Now C, C++

• Actually usually a mix of languages – Lowest levels in assembly – Main body in C – Systems programs in C, C++, scripting languages like PERL,

Python, shell scripts

• High-level language easier to port to other hardware – But slower

• Emulation can allow an OS to run on non-native hardware


5 of 26

Operating System Structure

• Various ways to structure an operating system:

– Monolithic structure

• Simple structure – MS-DOS

• More complex – UNIX

• More complex – Linux

– Layered – An abstraction

– Microkernel - Mach


6 of 26

MS-DOS

• MS-DOS – written to provide the most functionality in the least amount of space

• MS-DOS was limited by hardware funcionality. – Not divided into

modules – Although MS-DOS has

some structure, its interfaces and levels of functionality are not well separated


7 of 26

UNIX

• UNIX – the original UNIX operating system had limited structuring and was limited by hardware functionality.

• The UNIX OS consists of two separable parts – Systems programs

– The kernel • Consists of everything below the system-call interface

and above the physical hardware

• Provides the file system, CPU scheduling, memory management, and other operating-system functions; a large number of functions for one level


8 of 26

Traditional UNIX System Structure


9 of 26

Linux System Structure


10 of 26

Modularity

• The monolithic approach results in a situation where changes to one part of the system can have wide-ranging effects to other parts.

• Alternatively, we could design system where the operating system is divided into separate, smaller components that have specific and limited functionality. The sum of all these components comprises the kernel.

• The advantage of this modular approach is that changes in one component only affect that component, and no others, allowing system implementers more freedom when changing the inner workings of the system and in creating modular operating systems.


11 of 26

Layered Approach

• A system can be made modular in many ways. One method is the layered approach, in which the operating system is broken into a number of layers (levels). The bottom layer (layer 0) is the hardware; the highest (layer N) is the user interface.


12 of 26

Microkernel System Structure

• Moves as much from the kernel into user space • Mach example of microkernel

– Mac OS X kernel (Darwin) partly based on Mach

• 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

• Detriments: – Performance overhead of user space to kernel space

communication


13 of 26

Microkernel System Structure

Application

Program

File

System

Device

Driver

Interprocess

Communication

memory

managment

CPU

scheduling

messagesmessages

microkernel

hardware

user

mode

kernel

mode


14 of 26

Modules • Many modern operating systems

implement loadable kernel modules – Uses object-oriented approach – Each core component is separate – Each talks to the others over known

interfaces – Each is loadable as needed within the

kernel

• Overall, similar to layers but with more flexible – Linux, Solaris, etc


15 of 26

Hybrid Systems • In practice, very few operating systems adopt a

single, strictly defined structure. • Instead, they combine different structures, resulting

in hybrid systems that address performance, security, and usability issues. – For example, Linux is monolithic, because having the

operating system in a single address space provides very efficient performance. However, Linux are also modular, so that new functionality can be dynamically added to the kernel.

• We cover the structure of three hybrid systems: – Apple Mac operating system (laptop) – iOS (mobile operating systems) – Android (mobile operating systems)


16 of 26

Architecture of Mac OS X and iOS


17 of 26

Darwin

• Darwin uses a hybrid structure, and is shown Darwin is a layered system which consists primarily of the Mach microkernel and the BSD UNIX kernel.


18 of 26

Android

• Developed by Open Handset Alliance (mostly Google) – Open Source

• Similar stack to iOS • Based on Linux kernel but modified

– Provides process, memory, device-driver management – Adds power management

• Runtime environment includes core set of libraries and Dalvik virtual machine – Apps developed in Java plus Android API

• Java class files compiled to Java bytecode then translated to executable than runs in Dalvik VM

• Libraries include frameworks for web browser (webkit), database (SQLite), multimedia, smaller libc


19 of 26

Android Architecture


20 of 26

ACTIVITY


21 of 26

Operating-System Debugging

• Debugging is finding and fixing errors, or bugs • OS generate log files containing error information • Failure of an application can generate core dump file capturing

memory of the process • Operating system failure can generate crash dump file

containing kernel memory • Beyond crashes, performance tuning can optimize system

performance – Sometimes using trace listings of activities, recorded for analysis – Profiling is periodic sampling of instruction pointer to look for

statistical trends

Kernighan’s Law: Debugging is twce as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it.”


22 of 26

Performance Tuning

• Improve performance by removing bottlenecks

• OS must provide means of computing and displaying measures of system behavior

• For example, “top” program or Windows Task Manager


23 of 26

DTrace

DTrace tool in Solaris,

FreeBSD, Mac OS X allows

live instrumentation on

production systems

Probes fire when code is

executed within a provider,

capturing state data and

sending it to consumers of

those probes

Example of following

XEventsQueued system call

move from libc library to

kernel and back


24 of 26

Dtrace (Cont.)

DTrace code to record

amount of time each

process with UserID 101 is

in running mode (on CPU)

in nanoseconds


25 of 26

Operating System Generation

Operating systems are designed to run on any of a class of machines; the system must be configured for each specific computer site

SYSGEN program obtains information concerning the specific configuration of the hardware system Used to build system-specific compiled

kernel or system-tuned Can general more efficient code than one

general kernel


26 of 26

System Boot

• When power initialized on system, execution starts at a fixed memory location – Firmware ROM used to hold initial boot code

• Operating system must be made available to hardware so hardware can start it – Small piece of code – bootstrap loader, stored in ROM or

EEPROM locates the kernel, loads it into memory, and starts it – Sometimes two-step process where boot block at fixed

location loaded by ROM code, which loads bootstrap loader from disk

• Common bootstrap loader, GRUB, allows selection of kernel from multiple disks, versions, kernel options

• Kernel loads and system is then running


Documents

OS Generation and System Boot - SNS Courseware