Introduction To Linux

1. What is Linux?

Linux is an open-source, Unix-like operating system (OS) based on the Linux kernel. It is one of the most popular and widely used operating systems in the world, especially for servers, embedded systems, and cloud infrastructure.

✅ Key Characteristics of Linux:

• Open Source:

  The source code of Linux is freely available for anyone to modify and distribute under the GNU General Public License (GPL).

• Unix-like:

  Linux is modeled after the Unix operating system, meaning it follows Unix design principles such as:

  • Multi-user support

  • Multi-tasking

  • Hierarchical file system

  • Shell-based command-line interface

• Monolithic Kernel:

  Linux uses a monolithic kernel, meaning that the entire operating system core runs in a single address space for higher performance.

• Modularity:

  Linux is highly modular — components like file systems, device drivers, and network protocols are built as modules that can be loaded and unloaded as needed.

✅ Why Linux?

---

• Stability – Linux systems can run for years without needing a reboot.

• Security – Built-in permissions, firewall, and SELinux/AppArmor.

• Performance – Efficient use of resources, even on older hardware.

• Portability – Can run on various hardware architectures.

• Flexibility – Highly customizable (desktop environments, window managers, etc.)

• Free and Open Source – No licensing costs.

2. History of Linux

The Linux story begins in the early 1990s:

📌 Pre-Linux Era (1969 – 1991)

1. Unix (1969):

   • Created by Ken Thompson and Dennis Ritchie at Bell Labs (AT&T).

   • Written in C, making it portable across different hardware platforms.

   • Unix became popular in academic and commercial settings.

2. Minix (1987):

   • Created by Andrew S. Tanenbaum for teaching operating systems.

   • Minix was a simplified Unix-like OS but restricted in terms of licensing.

---

📌 The Birth of Linux (1991):

• Linus Torvalds, a Finnish computer science student, was frustrated by the limitations of Minix.

• In 1991, Linus began working on his own operating system kernel as a hobby project.

• On August 25, 1991, he posted this famous message to the comp.os.minix newsgroup:

"Hello everybody out there using Minix — I'm doing a (free) operating system (just a hobby, won't be big and professional like GNU) for 386(486) AT clones. This has been brewing since April and is starting to get ready."

---

📌 Early Linux Development (1991 – 1994):

• Torvalds released Linux 0.01 in September 1991 — just 10,000 lines of code.

• With help from other developers, Linux rapidly improved.

• The GNU Project (by Richard Stallman) provided essential system utilities and a shell (bash).

• In 1994, Linux version 1.0 was released, marking the first stable version.

---

📌 Growth and Adoption (1994 – Present):

• Major Linux distributions like Slackware (1993), Debian (1993), and Red Hat (1994) were created.

• Linux became popular for servers due to its stability and security.

• In the 2000s, Linux expanded to desktops (Ubuntu), cloud (AWS), and mobile (Android).

• Today, Linux powers over 90% of the cloud and nearly all supercomputers.

3. Linux Distributions

A Linux distribution (or distro) is a complete operating system based on the Linux kernel, packaged with:

• System libraries

• GNU utilities

• Software (desktop environment, tools, applications)

• Package management system

---

✅ Major Linux Distributions:

---

✅ Types of Distributions:

1. Debian-Based – Ubuntu, Linux Mint, Kali Linux

2. Red Hat-Based – Fedora, CentOS, RHEL

3. Arch-Based – Manjaro, EndeavourOS

4. Independent – Alpine, OpenSUSE

---

4. Difference Between Linux and Other OS

Linux Architecture (Kernel, Shell, File System, etc.)

Linux is a monolithic, Unix-like operating system. Its architecture follows a layered design where each layer interacts with the layer directly above or below it.

🛠️ Main Components of Linux Architecture:

The Linux architecture consists of 4 key components:

1. Hardware Layer – Physical components (CPU, memory, disk, devices).

2. Kernel – Core component that interacts with hardware and manages system resources.

3. Shell – Interface between the user and the kernel.

4. Application Layer – Programs and utilities that users interact with.

Linux Architecture

1. Hardware Layer

The hardware layer consists of the physical devices that Linux interacts with, such as:

• CPU – Central Processing Unit (executes instructions)

• Memory – RAM, Cache

• Storage – Hard drives (HDD, SSD), USB, etc.

• Input/Output – Keyboard, Mouse, Display, Network interfaces

✅ Example:

• When you press a key on the keyboard, the signal goes to the hardware.

• The kernel detects the signal and sends it to the active shell or application.

---

2. Kernel

The kernel is the core of the Linux operating system.

It is a monolithic kernel, meaning it runs everything (memory, processes, file systems) in the same address space, improving performance.

The kernel is the core component of an operating system. This provides a platform for programs and various services to run on top of it. The Linux kernel is modifiable according to the user’s needs. Overall, the Linux Operating System and Linux kernel together provide a strong and user-friendly platform.

✅ Key Functions of Kernel:

---

🏗️ Diagram of Kernel Structure:

 -----------------------------
|          USER SPACE         |
|-----------------------------|
|  SYSTEM CALL INTERFACE (API)|
|-----------------------------|
|          KERNEL SPACE       |
|-----------------------------|
|   Process Mgmt | Memory Mgmt |
|   File System  | Device Mgmt |
|   Network Mgmt | Security    |
 -----------------------------

---

✅ Types of Kernels:

1. Monolithic Kernel – Entire kernel runs in one space (Linux).

2. Microkernel – Only core components run in the kernel; other services run in user space (Minix).

3. Hybrid Kernel – Combination of monolithic and microkernel (Windows, macOS).

---

✅ Example: How Kernel Works

1. You type ls in the terminal.

2. The shell sends a system call to the kernel.

3. The kernel interacts with the file system to retrieve data.

4. The kernel sends the result back to the shell.

5. The shell displays the result to the user.

---

✅ System Calls

The kernel provides an interface for user programs through system calls.

Examples:

• open() – Opens a file

• read() – Reads from a file

• write() – Writes to a file

• fork() – Creates a new process

• exec() – Executes a new program

📌 Example:

strace ls

➡️ This shows the system calls made when you run ls.

---

3. Shell

The shell is an interface that allows the user to interact with the kernel.

It takes input from the user, processes it, and sends it to the kernel.

✅ Types of Shells:

---

✅ Example: Bash Shell Commands

# Display current directory
pwd
# Create a file
touch file.txt
# Display file content
cat file.txt
# List files
ls -l
# Remove a file
rm file.txt

---

✅ How Shell Works

1. User types ls -l in the terminal.

2. Shell interprets the command and sends a system call to the kernel.

3. Kernel accesses the file system and retrieves the list of files.

4. Result is sent back to the shell and displayed to the user.

---

🏗️ Diagram of Shell Interaction:

  USER <----> SHELL <----> KERNEL <----> HARDWARE

---

4. File System

The Linux file system organizes and manages data storage.

Everything in Linux (including devices) is represented as a file.

✅ File System Hierarchy:

---

✅ Example: File System Navigation

# List all files and directories
ls -l /
# Create a directory
mkdir /tmp/test
# Mount a drive
mount /dev/sdb1 /mnt
# Check disk usage
df -h
# Check file permissions
ls -l /etc/passwd

---

---

---

---

✅ How Everything Connects:

1. User types a command in the shell.

2. Shell sends the command as a system call to the kernel.

3. Kernel accesses hardware and file system to process the command.

4. Kernel sends output back to the shell.

5. Shell displays output to the user.

🌐 Real-World Example (DevOps View)

Let’s say you deploy a web app on Ubuntu Server:

1. Nginx (user space) receives an HTTP request.

2. It uses system calls (read, write, sendto) to talk to the kernel.

3. The kernel routes packets via the network stack.

4. The process scheduler allocates CPU time.

5. The file system reads static assets.

6. Response is sent back to the client — all coordinated seamlessly by Linux’s architecture.

What is Virtualization and Hypervisor types

Virtualization uses software to create an abstraction layer over computer hardware that allows the hardware elements of a single computer — processors, memory, storage, networking and more — to be divided into multiple virtual computers, commonly called virtual machines (VMs). Each VM runs its own operating system (OS) and behaves like an independent computer, even though it is running on just a portion of the actual underlying computer hardware.

OS virtualization is the use of software to allow a piece of hardware to run multiple operating system images at the same time. The technology got its start on mainframes decades ago, allowing administrators to avoid wasting expensive processing power.

There are several types of virtualization

• Server Virtualization:

• Desktop Virtualization:

• Application Virtualization:

• Network Virtualization:

• Storage Virtualization:

• Data Virtualization:

How virtualization works

Virtualization describes a technology in which an application, guest OS or data storage is abstracted away from the true underlying hardware or software.

This allows for greater flexibility, control and isolation by removing the dependency on a given hardware platform. While initially meant for server virtualization, the concept of virtualization has spread to applications, networks, data and desktops.

The Virtualization Layer is called Hypervisor.

The virtualization process follows the steps listed below:

1. Hypervisors detach the physical resources from their physical environments.

2. Resources are taken and divided, as needed, from the physical environment to the various virtual environments.

3. System users work with and perform computations within the virtual environment.

4. Once the virtual environment is running, a user or program can send an instruction that requires extra resources form the physical environment. In response, the hypervisor relays the message to the physical system and stores the changes. This process will happen at an almost native speed.

Virtual machines (VMs)

A virtual machine is a virtual representation, or emulation, of a physical computer. They are often referred to as a guest while the physical machine they run on is referred to as the host.

Virtualization makes it possible to create multiple virtual machines, each with their own operating system (OS) and applications, on a single physical machine.

A VM cannot interact directly with a physical computer. Instead, it needs a lightweight software layer called a hypervisor to coordinate between it and the underlying physical hardware. The hypervisor allocates physical computing resources — such as processors, memory, and storage — to each VM. It keeps each VM separate from others so they don’t interfere with each other.

What is a Hypervisor?

Before hypervisors hit the mainstream, most physical computers could only run one operating system (OS) at a time. This made them stable because the computing hardware only had to handle requests from that one OS. The downside of this approach was that it wasted resources because the operating system couldn’t always use all of the computer’s power.

A hypervisor solves that problem. It is a small software layer that enables multiple instances of operating systems to run alongside each other, sharing the same physical computing resources. This process is called virtualization, and the operating system instances are referred to as virtual machines (VMs)

A hypervisor is a hardware, software, or firmware that creates and runs Virtual Machines (VMs) using the resources of the physical host machine. It is a kind of emulator. The system on which a hypervisor runs one or more VMs is known as host machine and each VM is a guest machine.

The resources of the host machine are pulled by the hypervisor and allocated to different VMs that it has created.

Types Of Hypervisors

There are generally 2 types of hypervisors present.

1. Type 1 or Native or “bare metal” hypervisors

2. Type 2 or Hosted or “embedded” hypervisors

Type 1 vs. Type 2 Hypervisors

The Type 1 hypervisors are installed directly on top of physical servers or your hardware. This does not have to load any underlying Operating system. These are most used and most secure.

The type 2 hypervisors have a layer of host operating system that sits between host server and hypervisor. This is the reason these are called hosted hypervisors. They have higher latency than Native hypervisors.A Type 2 hypervisor doesn’t run directly on the underlying hardware. Instead, it runs as an application in an OS. Type 2 hypervisors rarely show up in server-based environments. Instead, they’re suitable for individual PC users needing to run multiple operating systems.

How Virtualization Works

1. The physical machine (host) runs a hypervisor.

2. The hypervisor creates and manages virtual machines (VMs).

3. Each VM acts like an independent computer with its own:

   • Virtual CPU

   • Virtual Memory

   • Virtual Disk

   • Network Interface

4. The hypervisor manages how resources are allocated between VMs.

📌 How Virtualization Works in Cloud (Example)

1. AWS uses the Xen hypervisor (Type 1) for most EC2 instances.

2. When you create an EC2 instance, the Xen hypervisor creates a VM.

3. The VM runs an independent Linux or Windows OS.

4. The hypervisor manages CPU, memory, and network resources.

Why Linux dominates in servers and cloud?

🌍 1. Linux = Built for Servers, Not Desktops

Unlike Windows, which evolved as a desktop OS, Linux was born in the data center.

From the beginning, its focus was on:

• Multi-user environments

• Networking efficiency

• Stability under heavy load

• Security & resource isolation

That DNA made it perfect for server-grade workloads — web servers, databases, containers, and now cloud VMs.

---

⚙️ 2. Open Source = Cost, Flexibility & Control

Linux is free and open source, meaning:

• No licensing costs (huge savings for data centers).

• Cloud providers (AWS, Google, Azure) can customize kernels for performance, security, or scalability.

• Anyone can tune, strip down, or optimize Linux for specific workloads.

Example:

AWS runs its own optimized version — Amazon Linux.

Google runs Container-Optimized OS (built on Linux).

Even Microsoft Azure uses Linux heavily behind the scenes.

---

🧱 3. Stability and Uptime

Linux is legendary for uptime — it can run years without a reboot.

That’s crucial for servers and production systems.

• No forced updates or restarts (unlike Windows Server).

• Minimal background services = less bloat, more predictability.

• Most production systems prefer LTS (Long-Term Support) releases for reliability.

---

🔒 4. Security and Permissions Model

Linux was designed around a strict permission and user model:

• Everything is a file → easy to audit and secure.

• Role-based access (root, sudo, normal user).

• SELinux and AppArmor provide kernel-level mandatory access controls.

• Transparent security patching (no GUI dependency).

In cloud environments where multi-tenancy is common, Linux’s security model is ideal.

---

🐳 5. Containers and Cloud-Native Revolution

The rise of containers (Docker, Kubernetes) sealed Linux’s dominance.

Containers depend on:

• cgroups (control groups)

• namespaces

• union file systems

👉 All of which are Linux kernel features.

That’s why:

• Kubernetes nodes typically run on Linux.

• Docker containers are based on Linux images.

• Even Windows containers use Linux kernel emulation layers (via WSL or Hyper-V).

---

⚡ 6. Performance and Resource Efficiency

Linux can run comfortably even on 128 MB RAM servers — making it perfect for lightweight VMs or microservices.

• No heavy GUI (unless installed).

• Systemd or init gives precise boot control.

• Tunable for real-time, I/O, or memory optimization.

That translates into lower operational costs in the cloud.

---

☁️ 7. Cloud Integration & Automation

Linux integrates natively with DevOps and Cloud tooling:

• SSH for remote management

• Cron jobs, systemd timers for automation

• Scripting (Bash, Python, Ansible)

• Package managers (apt, yum, dnf, zypper)

• APIs and agents (CloudWatch, Prometheus, Grafana exporters)

Every DevOps pipeline tool (Jenkins, Terraform, Ansible, Kubernetes, etc.) runs best on Linux.

---

🧠 8. Ecosystem and Community Power

Linux has a massive global community:

• Continuous kernel development and security patching.

• Thousands of distributions (Ubuntu Server, CentOS, Debian, Red Hat, SUSE, AlmaLinux).

• Enterprise support from Red Hat, Canonical, SUSE, etc.

This community-driven development ensures faster innovation and stronger security response.

---

🖥️ 9. Cross-Platform and Cloud Provider Neutrality

Linux doesn’t belong to any single company.

That’s why:

• AWS, Azure, GCP, DigitalOcean, and even Oracle Cloud all use Linux.

• Enterprises can move workloads across clouds easily with minimal change.

This vendor-neutrality gives Linux unmatched flexibility.

---

🧩 10. Industry Adoption and Stats

Let’s look at actual numbers:

• Over 96% of top 1 million web servers run on Linux.

• All top 500 supercomputers use Linux.

• Around 90% of public cloud workloads run on Linux-based systems.

• Android (based on Linux kernel) dominates mobile, extending its reach further.

Real-World Example

AWS EC2 instance types like t2.micro or m5.large are optimized for Amazon Linux or Ubuntu Server because:

• Boot time is faster

• Less memory overhead

• Better integration with cloud agents (CloudWatch, SSM)

• Kernel tuned for virtual environments

Raj Nandgaonkar

Happy learning