LAYERS AND LEVELS OF LINUX OS

The Linux operating system structure can be conceptually divided into several
layers, each serving a specific purpose and providing a different level of
abstraction. Here are the layers of the Linux operating system structure:
The main components of Linux operating system are: Application, Shell,
Kernel, Hardware, Utilities

1. Hardware Layer:
The hardware layer, often referred to as the hardware abstraction layer (HAL),
is the lowest level of the Linux operating system structure. It directly interacts
with the physical components of a computer system. Here's a more detailed
overview of the hardware layer:
Processor (CPU):
The processor is the brain of the computer. It executes instructions stored in
memory, performs calculations, and manages the flow of data within the
computer system. Linux must be compatible with the specific architecture of
the CPU, which can include x86, x86_64, ARM, and others.
Memory (RAM):
Random Access Memory (RAM) is the volatile memory used by the operating
system and applications to store data temporarily. The operating system
manages memory allocation and ensures that each running process has access
to the required memory resources.
Storage Devices:
Linux supports various storage devices, including hard disk drives (HDDs), solid-
state drives (SSDs), USB drives, and network-attached storage (NAS) devices.
These storage devices are used to store the operating system, applications, and
user data.
Input/Output Devices:
Linux interfaces with input devices like keyboards, mice, touchpads, and other
peripherals. It also communicates with output devices such as monitors,
printers, speakers, and displays. Device drivers facilitate communication
between the Linux kernel and these input/output devices.
Network Interface Cards (NICs):
Network interface cards allow computers to connect to networks, including
local area networks (LANs) and the internet. Linux supports a wide range of
network interfaces, both wired and wireless, enabling connectivity and
communication between devices.
Motherboard & Bus Architecture:
The motherboard houses various components and provides the physical
connections between the CPU, memory, storage devices, and expansion cards.
Linux must be compatible with the motherboard's bus architecture, such as PCI
(Peripheral Component Interconnect) or PCIe (PCI Express), to ensure proper
communication with peripheral devices.
Graphics Processing Unit (GPU):
GPUs are responsible for rendering graphics and accelerating certain
computational tasks. Linux interacts with GPUs to enable graphical displays,
whether through a command-line interface (using framebuffer devices) or
graphical user interfaces (using X.Org or Wayland display servers).
BIOS/UEFI & Firmware:
The Basic Input/Output System (BIOS) or Unified Extensible Firmware Interface
(UEFI) is firmware stored on the computer's motherboard. It initializes
hardware components during the boot process. Linux relies on BIOS/UEFI
interfaces to initiate the boot sequence and access essential hardware
information.
The hardware layer serves as the foundation for the entire Linux operating
system. Device drivers and kernel modules bridge the gap between the
hardware layer and the kernel, allowing Linux to control and utilize the
computer's physical resources effectively. Through these interactions, Linux
provides a platform for running applications and enabling user interactions.
2. Kernel Layer:
The kernel layer is the core of the operating system. It is a fundamental
component responsible for managing system resources, providing essential
services, and acting as an intermediary between software applications and
hardware components. The kernel is divided into the following components:

Process Management:
Process Creation and Termination: The kernel creates, terminates, and
manages processes. Each process has its memory space, resources, and
execution context.
Process Scheduling: The kernel schedules processes for execution on the CPU,
ensuring fair and efficient utilization of system resources.
Memory Management:
Virtual Memory: The kernel manages virtual memory, allowing processes to
access more memory than physically available by swapping data between RAM
and storage devices.
Memory Protection: It enforces memory protection to prevent processes from
accessing unauthorized memory areas.
File System Management:
File I/O Operations: The kernel handles file input/output operations, allowing
processes to read from and write to files.
File System Drivers: It interfaces with various file systems (ext4, FAT, NTFS, etc.)
to enable the reading and writing of different storage formats.
Device Divers:
Communication with Hardware: The kernel communicates with hardware
devices through device drivers, allowing software applications to interact with
hardware components like printers, network interfaces, and storage devices.
Plug and Play: It supports plug-and-play functionality, enabling the system to
recognize and configure newly connected hardware devices.
Network Stack:
Networking Protocols: The kernel includes networking protocols (TCP/IP, UDP)
and manages network connections, facilitating communication between
devices over a network.
Firewall and Security: It often incorporates firewall functionalities and security
measures to protect the system from unauthorized access and attacks.
System Call Interface:
System Call Interface provides a connection between user space and kernel
space. It is an integral part of the Linux kernel, enabling user-level applications
to request essential services and interact with the underlying hardware
through well-defined system calls.
Architecture-dependent Code:
System code specific to the type of processor. It is the low-level code that
interacts directly with the hardware and is specific to the CPU architecture
being used. This code includes things like interrupt handling, memory
management specific to the hardware, and assembly language routines
tailored for the CPU's instruction set.
Most Linux distributions employ a monolithic kernel architecture. Some (GNU)
use a microkernel. In monolithic design, the operating system's core services
and modules, including device drivers and file systems, all run in a single
address space, known as kernel space. User applications operate separately in
their space, called user space. This segregation ensures that kernel processes
are protected and provides faster performance due to direct access to
hardware resources.
Monolithic Kernel:
Monolithic kernels consist of dynamically loadable and unloadable modules
that handle specific functions within the kernel space. All essential services
coexist in the same address space, making these kernels efficient in terms of
performance.
Microkernel:
Contrastingly, microkernels adopt a different approach. A small kernel residing
in kernel space manages essential functions like memory and multitasking.
Most other traditional kernel services, such as device drivers and file systems,
are implemented as separate 'servers' running in user space. This separation
provides enhanced system stability and security. If a non-essential service fails,
it does not jeopardize the entire system. However, this architecture introduces
potential performance overhead due to interprocess communication between
user space servers and the microkernel.
So the kernel layer is crucial for the stability, security, and overall performance
of the operating system. It acts as the heart of the system, managing resources
efficiently and allowing various software applications to run seamlessly on a
wide range of hardware configurations.
3. Shell and Command Layer:
The "Shell and Command Layer" is an important component of the Linux
Operating System Structure, and it plays a critical role in enabling user
interaction with the system. Let's dive deeper into this layer:
The Shell:
The shell is a command-line interface that allows users to interact with the
operating system. It is a program that interprets user commands and passes
them to the operating system for execution. Linux offers several shell options,
with the most common ones being Bash (Bourne Again Shell), sh (Bourne
Shell), and others like Zsh, Fish, and Tcsh. The shell provides a text-based
environment where users can enter commands, scripts, and perform various
operations.
Command Line Interface (CLI):
The Shell and Command Layer provides a CLI for users. In a CLI, users type
commands, and the shell interprets and executes these commands. The CLI is
highly flexible and powerful, enabling users to perform a wide range of tasks,
from simple file management to complex system administration.
Command Language:
Each shell has its own command language. For example, Bash has its set of
commands and syntax. Users can execute built-in shell commands or external
commands (programs) installed on the system.
Scripting:
One of the key features of the Shell and Command Layer is the ability to create
and run scripts. Shell scripts are text files containing a series of commands.
These scripts can automate tasks, making them more efficient.
Pipelines & Redirection:
The shell allows users to connect commands through pipelines, where the
output of one command is passed as input to another. Redirection allows users
to manipulate input and output streams. For instance, users can redirect
program output to a file or use it as input from a file.
Customization:
Users can customize their shell environment by defining aliases, setting
environment variables, and configuring the prompt. These customizations help
users tailor their interaction with the shell to meet their specific needs.
Job Control:
The shell supports job control, enabling users to manage multiple tasks or
processes simultaneously. Users can run processes in the background, suspend
them, or bring them to the foreground.
Interactive & Non-Interactive Use:
The shell can be used interactively, where users enter commands directly. It can
also be used non-interactively by executing scripts or batch processes.
Administrative Tasks:
System administrators heavily rely on the Shell and Command Layer to manage
the system. They can create scripts to automate system maintenance and
configuration tasks.
Accessibility:
The shell and command-line interface provide accessibility options for users
who may require screen readers, braille displays, or other assistive
technologies.
In summary, the Shell and Command Layer is a fundamental part of the Linux
Operating System Structure, providing users with a powerful and flexible
means of interacting with the system, executing commands, automating tasks,
and managing processes. It's a critical component for both regular users and
system administrators.
4. User Space Libraries and Utilities:
Above the shell, there are libraries and utilities that provide additional
functionalities and simplify the development of applications. These libraries,
often provided by GNU (GNU's Not Unix) Project, offer pre-built functions that
can be used by application developers. Common libraries include the GNU C
Library (glibc) and the GNU Core Utilities.
Definition:
The User Space Libraries and Utilities Layer consists of various software
libraries and utility programs that provide essential functions to user
applications.
Libraries:
System Libraries: These libraries provide fundamental functions and services to
applications. For example, the C library (libc) contains standard functions like
printf and malloc.
Specialized Libraries: Libraries like OpenGL and GTK+ offer specific
functionalities for graphics and graphical user interfaces.
Utilities:
Command-Line Utilities: Programs like ls, cp, and grep are essential for
interacting with files, searching, and managing system resources through the
terminal.
System Configuration Tools: Utilities such as systemctl and ifconfig allow users
to configure system settings and network interfaces.
Package Managers: Tools like apt (used in Debian-based systems) and yum
(used in Red Hat-based systems) enable users to install, update, and manage
software packages.
Text Editors: Utilities like nano, vim, and gedit provide text editing capabilities
for configuration files and scripts.
Functions:
Abstraction: Libraries abstract complex low-level operations, allowing
developers to focus on higher-level application logic without dealing with
intricate hardware details.
Efficiency: Utilities optimize common tasks, enhancing system performance and
enabling users to accomplish tasks more quickly and efficiently.
Customization: Users can customize their Linux environment by installing
different libraries and utilities based on their specific needs.
Flexibility and Open Source:
Open Source Nature: Most libraries and utilities in this layer are open source,
fostering collaboration, innovation, and continuous improvement within the
Linux community.
Flexibility: The availability of diverse libraries and utilities allows users to tailor
their Linux experience according to their preferences, making it a versatile and
customizable operating system.
In summary, the User Space Libraries and Utilities Layer in Linux provides
essential functions, tools, and resources necessary for both developers and
users. It abstracts complex operations, enhances efficiency, and embodies the
open source spirit, making Linux a powerful and adaptable operating system.
5. System Services and Daemons:
Linux runs various system services and daemons in the background to perform
tasks like network management, printing, logging, and scheduling. These
services are managed by init systems like Systemd or older init scripts and run
independently of user interactions. This play a crucial role in providing essential
background functions that enable various aspects of the system to operate
smoothly.
Definition:
System Services: These are specialized software components that handle core
system functions, such as networking, printing, or logging.
Daemons: Daemons are background processes that run without user
intervention, providing continuous services. They often start at system boot
and wait for specific events or requests to perform tasks.
Roles and Functions:
Networking Services: Daemons manage network-related tasks like DHCP
(Dynamic Host Configuration Protocol) for automatic IP assignment, DNS
(Domain Name System) resolution, and firewall configurations.
Printing Services: Print daemons control print jobs, ensuring they are sent to
the correct printers and managing print queues efficiently.
Logging and Monitoring: Daemons handle system and application logs, storing
valuable information for troubleshooting. Monitoring daemons continuously
check system health and performance metrics.
Task Scheduling: Services like Cron manage scheduled tasks, automating
repetitive processes at specified intervals.
File Sharing and Remote Access: Daemons enable file sharing over networks
(e.g., Samba for Windows file sharing) and remote access protocols (e.g., SSH
for secure shell connections).
Daemon Characteristics:
Background Operation: Daemons run in the background, enabling users to
interact with the system without interruption.
Autostart: Many daemons start automatically when the system boots, ensuring
essential services are available from the beginning.
Configurability: Administrators can configure daemons using specific
configuration files, allowing customization based on system requirements.
Error Handling: Daemons are designed to handle errors gracefully, ensuring the
system continues to operate even when specific services encounter issues.
Interactions:
Inter-Process Communication (IPC): Daemons communicate with other system
components and applications through IPC mechanisms, enabling seamless data
exchange.
User Commands: Users can interact with daemons indirectly through
commands or graphical interfaces, requesting specific services or information.
In summary, system services and daemons are essential components of the
Linux OS, ensuring that critical background tasks are managed efficiently. They
enhance system functionality, provide continuous services, and enable users
and applications to interact with the system seamlessly. Understanding and
configuring these services are fundamental skills for Linux system
administrators.
6. Graphical User Interface (GUI) Layer:
Graphical User Interface (GUI) Layer serves as the interface between the user
and the operating system. It's the part of the system that allows users to
interact with the computer using visual elements like windows, icons, buttons,
and menus, rather than relying solely on text-based commands. Popular GUI
environments include GNOME, KDE, and Xfce.
Definition:
The GUI Layer is the visual interface of the operating system. It provides a user-
friendly environment where users can interact with the computer and its
applications through graphical elements, making it intuitive and accessible.
Components:
Windows: Applications run within individual windows, allowing users to
multitask efficiently by switching between different programs.
Icons: Represent files, folders, applications, and other resources. Users can click
on icons to open or execute corresponding items.
Menus: Provide a list of options and actions. Users can access various functions
by selecting menu items.
Buttons: Interactive elements that perform actions when clicked, often found in
dialog boxes and toolbars.
Graphics: GUIs can display images, charts, and other graphical content,
enhancing the visual experience.
Pointers: GUIs use graphical pointers, commonly known as cursors, controlled
by devices like mice or touchpads.
Functions:
Interactivity: GUIs enable users to perform tasks by directly interacting with
visual elements, reducing the need for memorizing complex commands.
File Management: Users can manipulate files and folders using drag-and-drop,
copy-paste, and other intuitive actions.
Application Management: GUIs allow users to launch, switch between, and
close applications effortlessly.
Customization: Users can often personalize their desktops, changing
wallpapers, themes, and icon arrangements.
Accessibility: GUIs enhance accessibility by providing options like screen
readers, magnifiers, and keyboard shortcuts.
In summary, the Graphical User Interface Layer in the Linux OS structure
simplifies user interactions, making computing more accessible and visually
engaging. It offers a diverse range of elements and functions, enhancing the
overall user experience in the digital realm.
7. Application Layer:
Users run applications on top of the Linux operating system. Applications can
be command-line tools or graphical software. Examples include web browsers,
text editors, media players, development tools, and office suites. These
applications utilize the underlying layers to provide functionality to users.
User Interaction:
At this layer, users interact with the system through graphical user interfaces
(GUIs) or command-line interfaces (CLIs). GUIs provide intuitive visual
elements, while CLIs allow users to input commands directly into the terminal.
Diverse Applications:
A wide range of applications resides in this layer, catering to different user
needs. These applications can be installed from software repositories using
package managers, ensuring easy access and updates.
Interoperability:
Linux applications are often designed to be compatible with various desktop
environments, ensuring a consistent user experience across different Linux
distributions.
Customizability:
Linux offers flexibility, allowing users to customize their desktop environments,
themes, and application layouts according to their preferences. This high
degree of customization is a hallmark of Linux-based systems.
Security:
Linux applications operate within the user's permissions, ensuring security.
Users need appropriate permissions to install or modify applications,
enhancing system security.
Open Source Ecosystem:
Many Linux applications are open source, meaning their source code is
accessible to users. This fosters collaboration, innovation, and a strong
community-driven development model.
In summary, the Application Layer in Linux serves as the gateway for users,
offering a rich ecosystem of diverse, customizable, and secure applications.
Whether through user-friendly interfaces or powerful command-line tools,
Linux applications empower users to perform a wide array of tasks, making the
Linux experience versatile and user-centric.
A linux system mainly has 3 layers

 Processes The kernel is responsible for determining which processes are

allowed to use the CPU.
 Memory The kernel needs to keep track of all memory—what is
currently allocated to a particular process, what might be shared
between processes, and what is free.
 Device drivers The kernel acts as an interface between hardware (such as
a disk) and processes. It’s usually the kernel’s job to operate the
hardware.
 System calls and support Processes normally use system calls to
communicate with the kernel. We’ll now briefly explore each of these
areas.
  Most older Operating system are monolithic that is whole operating
system is a single executable file that runs in kernel mode.
 This binary contains the process management , memort management ,
file system and the rest (Ex. Unix)
 The alternative is microkernel base system , in which most of the OS run
as separate processes , mostly outside the kernel
 They communicate by message passing the kernels job is to handle the
message passing, interrupt handling , low-level process management and
possible the I/O . ( Ex. Mach , GNU Hurd )


Monolithic Kernel Microlithic Kernel

Kernel Size Increases because kernel +

kernel size is small because
kernel subsystems compiled as single
kernel subsystem
binary

Easily extensible and bug

Difficult to extension or bug fixing
fixing

Need to Compile entire source code Easy recover from crash

 Monolithic Kernel Microlithic Kernel

slow due to complex message

bad maintainability
passing between services

Process Management is
fast , run as single binary
complex

Communication between service is

Communication is slow
faster

Easily recoverable from

No Crash Recovery
crashing

More Secure

MACos , Windows NT , QNX

Linux , window etc
etc

Process management
 Process management describes the starting, pausing, resuming,
scheduling, and terminating of processes. The concepts behind starting
and terminating processes are fairly straightforward, but describing how
a process uses the CPU in its normal course of operation is a bit more
complex. On any modern operating system, many processes run
“simultaneously.”
 The kernel is responsible for context switching.

Process
Running instance of a program is called a PROCESS
If you have two terminal window showing on your screen then you are
probably running the same terminal program twice-you have two
terminal processes
 Each terminal window is probably running a shell; each running shell is
another process
when you invoke a command from a shell, the corresponding program is
executed in a new process
The shell process rumes when that process complete

Process vs Program
A program is a passive entity ,such as file containining a list of
instructions stored pm a disl
Process is a activeentity , with a program counter specifying the next
instruction to execute and a set of associated resources
A program becomes a process when an executable file is loaded into
main memory

Lecture Notes on Key Operating System Concepts

1. Memory Management
Memory management is a critical function of operating systems that
handles the allocation, organization, and protection of memory
resources.
1.1 Objectives of Memory Management:
 Efficient utilization of memory resources.
 Isolation and protection between processes.
 Support for multitasking and concurrency.
 Handling memory hierarchies (RAM, cache, disk).
1.2 Key Concepts:
1. Address Spaces:
o Logical Address: Generated by the CPU, also known as virtual
address.
 o Physical Address: Actual location in physical memory.
o Mapping: Achieved using Memory Management Unit (MMU).
2. Memory Allocation Techniques:
o Contiguous Allocation: Single continuous block of memory.
o Paging: Divides memory into fixed-sized pages and page frames.
o Segmentation: Divides memory into segments based on logical
divisions.
3. Virtual Memory:
o Allows execution of processes larger than physical memory.
o Implements demand paging and swapping.
o Uses page tables and Translation Lookaside Buffers (TLBs).
4. Fragmentation:
o Internal: Wasted space within allocated memory.
o External: Wasted space between allocated memory blocks.
5. Garbage Collection:
o Reclaims memory no longer used by programs.
6. Protection and Sharing:
o Enforces access permissions (read, write, execute).
o Enables inter-process communication (IPC).
2. Device Drivers and Management
Device management involves managing hardware devices through
device drivers, which act as intermediaries between the OS and
hardware.
2.1 Device Driver:
 A software component that controls a specific hardware device.
 Provides a uniform interface to access devices.
 Types: Character drivers, Block drivers, Network drivers.
 2.2 Responsibilities of Device Management:
1. Device Communication:
o I/O instructions and data transfer.
o Direct Memory Access (DMA) for faster operations.
2. Device Scheduling:
o Organizes access to shared devices (e.g., printers, disk drives).
3. Buffering and Caching:
o Temporary storage to handle speed mismatches.
4. Error Handling:
o Detects and recovers from device failures.
5. Plug and Play Support:
o Automatically detects and configures hardware devices.
3. System Calls and Support
System calls provide the interface between user applications and the
operating system.
3.1 Definition and Purpose:
 Allow user-space programs to request OS services.
 Abstract low-level hardware details.
3.2 Types of System Calls:
1. Process Control:
o Examples: fork(), exec(), wait(), exit().
2. File Management:
o Examples: open(), read(), write(), close().
3. Device Management:
o Examples: ioctl(), read(), write().
4. Information Maintenance:
o Examples: getpid(), alarm(), sleep().
5. Communication:
o Examples: pipe(), shmget(), socket().
3.3 System Call Implementation:
 Traps: Transition from user mode to kernel mode.
 Return to user space with results.
4. User Space
User space is the portion of system memory where user applications
execute.
4.1 Characteristics:
 Separated from kernel space for security and stability.
 Applications have limited access to hardware resources.
4.2 User Space Libraries:
 Provide APIs for system call access.
 Examples: libc, glibc.
4.3 Interaction with Kernel:
 Through system calls.
 Uses IPC mechanisms for communication between processes.
5. Users
Users interact with the operating system at various levels, from basic
application usage to administrative control.
5.1 User Types:
1. Normal Users:
o Limited permissions.
o Access to personal files and some shared resources.
2. Superusers (Administrators):
o Full control over the system.
o Can manage users, processes, and hardware.
 5.2 User Management:
 User Accounts: Defined by username, password, and UID.
 Groups: Logical collections of users for access control.
 Authentication and Authorization: Ensures secure access.
5.3 User Interfaces:
1. Command-Line Interface (CLI):
o Direct interaction with the OS through commands.
o Examples: Bash, PowerShell.
2. Graphical User Interface (GUI):
o Visual and interactive interface.
o Examples: Windows Explorer, GNOME, KDE.