ASSIGNMENT-2

Name:- Parla Surendra Mani Kumar

Enroll no :- 16116043
ECE- 3rd year
Layered Architecture in :-
a) WINDOWS:-
Windows architecture consists of two modes user mode and kernel mode.
This is a modular structure and it is composed of many simple modules. User mode
has limited access to the system resources while the kernel mode has unrestricted
access to the system resources like external drivers and memory.
Kernel Mode consists of hardware abstraction layer (HAL), kernel and executive
services. HAL abstracts the hardware differences from the operating system. This
makes windows portable on different hardware platforms. Windows kernel is also
known as hybrid kernel. Kernel schedules the activities of CPU and also synchronizes
the activities among processors to optimise the performance. Kernel mode stops user
mode and apps from accessing critical areas of OS. Micro kernel provides address
space management, thread management and inter process communication (IPC).
The major works of kernel are thread scheduling, interrupt handling, low level
processor synchronisation and recovery from power failure. Executive services
provide common services like object management, process management, power
management, security.
User mode consists of internal subsystem and environment subsystem. The
environment subsystem allows windows to run applications developed for different
platforms like win32, win16, OS/2, and POSIX. The internal subsystem manages
permissions to user accounts. It accepts login requests and performs authentication.
 Fig-1: Layered Architecture in Windows

b)UNIX:-
The UNIX operating system consists of a kernel layer, shell layer and an application
layer. These three layers create a multiuser and multi-tasking OS.
Kernel Layer: - The Kernel is the core of UNIX OS. It is a piece of hardware that
interacts with the machine's hardware. Programmes access the kernel using a set of
system calls. It performs the following services like process, memory, file and network
management and is responsible for ensuring that all processes are running
concurrently. It is also responsible for process creation and termination.
Shell Layer: - Shell is the layer that acts as an interface between user and kernel. It
interprets the commands that are typed in the terminal. Users can also put their
commands in a file and give it to terminal. The series of commands is called shell
script. There are different shells that are used by UNIX OS. They include the C shell,
Korn shell, Bourne shell and Bourne Again shell. There could be several shells in
action for a user who logged in.
Application Layer: - It is the final layer of UNIX OS. It consists of word processors,
database management and graphic processors. These programs were accessed by
commands but they can also be accessed by GUI.
 Fig-2: Layered Architecture in UNIX

c)LINUX: - Linux OS is similar to UNIX. It has two major levels Linux kernel and
user processes. Kernel is the core of Linux OS. It manages all the hardware and acts
as an interface between hardware and any user running program. Linux kernel
consists of system calls, power management, memory management and device
drivers. Virtual memory allocation is also done in kernel.
User processes consists of the running processes that kernel manages. It has GUI,
servers and shell. All web servers run as user programs. The most important user
utilities is shell, the standard command line interface on UNIX systems. Linux
supports many shells, the most common is the bourne-Again shell (bash). The user
utilities also include simple file management such as those to copy files, create
directories and edit text files.

Fig- 3: Layered Architecture in Linux

The major difference between kernel programs and user programs is that kernel
programmes run in privileged mode known as kernel mode. In Linux no user code is
built into the kernel. User mode has access only to a controlled subset of systems
resources while the kernel mode has full access to all the physical resources of the
computer. In LINUX the Communicatiuon between various subsystems is done using
relatively cheap C function invocation and not by more complicated Inter Process
Communication (IPC) as in windows.