PL - 001 — Linux Fundamentals & Ecosystem
Introduction to Linux Operating System
Linux is an open-source, Unix-like operating-system kernel created by Linus Torvalds in 1991.
Today, Linux forms the foundation of operating systems used across servers, cloud infrastructure, containers, networking, embedded systems, high-performance computing, and developer environments.
It is a system for managing processes, memory, storage, devices, networking, users, permissions, and system resources.
Technically, Linux is the kernel, not the complete operating system. A complete Linux-based system combines the kernel with user-space components such as system libraries, shells, utilities, services, package-management tools, and applications. These combinations are distributed as Linux distributions.
The kernel is responsible for managing system resources and providing controlled access to hardware. Applications interact with the kernel primarily through the system-call interface.
The importance of Linux is not simply the number of systems running it. Its greater significance is that Linux exposes many of the fundamental mechanisms through which modern computing systems operate.
When working with Linux, we eventually encounters concepts such as:
- Processes
- Threads
- CPU Scheduling
- Virtual Memory
- Filesystems
- Storage
- Sockets
- Networking
- Permissions
- System Calls
- Signals
- Services
- Logs
- Resource Limits
- Isolation
- Security
These are not isolated Linux topics. They are fundamental operating-system and systems-engineering concepts. Linux provides a practical environment in which these concepts can be observed directly.
For example, rather than learning process management only as theory, we can create processes, inspect their state, observe CPU and memory usage, trace system calls, examine open file descriptors, inspect network sockets, and analyze how the system behaves under resource pressure.
That makes Linux particularly valuable as an engineering learning and experimentation platform.
If an application is slow, the investigation may move through CPU scheduling, memory pressure, filesystem latency, network latency, process state, or application behavior.
If a service cannot start, the investigation may involve configuration, permissions, dependencies, ports, systemd, logs, filesystem access, or security policy.
If a remote connection fails, the investigation may move through DNS, routing, interfaces, firewall rules, sockets, and the application itself.
Linux should not be approached merely as a list of commands to memorize. The important foundation is understanding the relationship between the kernel, user space, processes, resources, filesystems, networking, security, services, and the distribution ecosystem.
Together, these concepts explain why Linux has become such a significant platform for modern engineering.
Linux Operating System Architecture
The practical relationship between the major components can be summarized as:
User Applications
│
▼
Shells / System Utilities
│
▼
System Libraries
│
▼
System Call Interface
│
▼
Linux Kernel
│
├── Process / Task Management
├── CPU Scheduling
├── Memory Management
├── VFS / Filesystems
├── Networking
├── IPC
├── Security
├── Device Drivers
├── Kernel Modules
└── Architecture-specific Code
│
▼
Hardware
The important architectural boundary is between user space and kernel space. Applications normally execute with restricted privileges in user space, while the kernel operates with the privileges required to manage CPU, memory, devices, networking, and other system resources.
LINUX-BASED OPERATING SYSTEM ARCHITECTURE
---------------------------------------------------------------------------
| USER SPACE |
---------------------------------------------------------------------------
| |
| User Applications |
| - Web Browsers | Editors | Servers | Custom Programs |
| |
| Shells & System Utilities |
| - bash | zsh | system utilities |
| |
| System Libraries |
| - glibc and other user-space libraries |
| |
---------------------------------------------------------------------------
| SYSTEM CALL INTERFACE |
| - Interface between User Space and Kernel |
---------------------------------------------------------------------------
| KERNEL SPACE |
---------------------------------------------------------------------------
| LINUX KERNEL |
| |
| - Process / Task Management - CPU Scheduling |
| - Memory Management - VFS / Filesystems |
| - Networking - IPC |
| - Security - Device Drivers |
| - Kernel Modules - Architecture-specific code |
| |
---------------------------------------------------------------------------
| HARDWARE |
---------------------------------------------------------------------------
| CPU | RAM | Storage | Network | GPU | I/O Devices |
---------------------------------------------------------------------------
The kernel manages resources and provides operating-system primitives.
The user space provides the environment in which applications, services, shells, libraries, and administration tools execute.
The distribution packages these components into an installable and maintainable operating-system environment.
This distinction is particularly important when troubleshooting. A problem may originate in an application, library, system service, kernel subsystem, driver, or hardware layer even though all of them are commonly described simply as “Linux.”
Open-Source Concepts & Linux Philosophy
Linux is developed and distributed under an open-source model. The source code can be inspected, modified, and redistributed according to its applicable license.
The Linux kernel is licensed under the GNU General Public License, version 2 (GPLv2), with an explicit syscall exception. A complete Linux distribution contains many additional projects with their own licenses.
Open source provides several advantages:
- Transparency — implementation can be inspected.
- Modifiability — software can be adapted to specific requirements.
- Collaboration — changes can be developed and reviewed by a global community.
- Portability — Linux can be adapted to different architectures and hardware.
- Ecosystem development — organizations can build products and platforms around the kernel.
Linux development is largely coordinated through the upstream kernel project, while distributions and vendors may maintain additional downstream changes, patches, and configurations.
Traditional Unix Philosophy
├── Small, focused tools
├── Tools designed to work together
├── Standard interfaces
├── Text-based configuration and output
├── Pipelines and composability
├── Consistent abstractions where practical
└── Automation through scripting
Unix vs Linux — Legacy and Modern Systems
Linux is Unix-like, but it is not the original Unix operating system.
Unix originated at Bell Labs and became one of the most influential operating-system families in computing history.
Linux later adopted many Unix concepts and interfaces while being developed independently.
Unix
├── Historical operating-system family
├── Originated at Bell Labs
├── Commercial and academic variants
├── Influenced POSIX and modern OS interfaces
└── Major influence on operating-system design
Examples of historically significant Unix or Unix-derived systems include:
Unix / Unix-derived ecosystem
├── AT&T Unix
├── BSD
├── Solaris
├── AIX
├── HP-UX
└── Other commercial / academic variants
Linux
├── Open-source Unix-like kernel
├── Started by Linus Torvalds in 1991
├── Independent implementation
├── Uses many Unix/POSIX concepts and interfaces
└── Foundation for modern Linux distributions
The Practical Relationship
Unix
└── Historical operating-system family and design influence
↓ influence
Linux
└── Independent Unix-like kernel implementation
↓ combined with user-space components
Linux Distributions
└── Complete Linux-based operating-system environments
Linux therefore shares many concepts with Unix—processes, permissions, shells, pipes, files, file descriptors, signals, sockets, and hierarchical filesystems—without being a descendant of the original Unix source code.
Modern Linux has also evolved substantially beyond traditional Unix environments, supporting virtualization, containers, large-scale cloud infrastructure, advanced networking, modern hardware, and extensive security isolation.
Major Linux Distributions & Enterprise Variants
A Linux distribution packages the Linux kernel together with user-space software, system-management tools, repositories, configuration, and a defined release model.
The major Linux distributions and enterprise variants include:
- Debian — Known for stability and broad package availability; widely used on servers, desktops, development systems, and embedded platforms.
- Ubuntu — Based on Debian; widely used for desktops, software development, servers, cloud infrastructure, and enterprise deployments.
- Red Hat Enterprise Linux (RHEL) — Enterprise-focused distribution commonly used for business-critical servers, data centers, hybrid cloud, and enterprise infrastructure.
- SUSE Linux Enterprise (SLE) — Enterprise Linux platform used for servers, data centers, cloud environments, SAP workloads, and edge deployments.
- Fedora — Community-driven distribution focused on current technologies, developer workstations, containers, and experimentation with emerging Linux technologies.
- Arch Linux — Lightweight and highly customizable distribution commonly used by advanced users, developers, and engineers who want direct control over system configuration.
Other popular Linux distributions include Linux Mint, Rocky Linux, AlmaLinux, and openSUSE, each serving different desktop, server, compatibility, or enterprise-oriented requirements.
Linux Distribution Ecosystem
│
├── Debian
│ └── Stable servers, desktops, development, embedded
│
├── Ubuntu
│ └── Desktop, development, servers, cloud, enterprise
│
├── Red Hat Enterprise Linux (RHEL)
│ └── Enterprise servers, data centers, hybrid cloud
│
├── SUSE Linux Enterprise (SLE)
│ └── Enterprise systems, SAP, cloud, edge
│
├── Fedora
│ └── Developer workstations, containers, emerging technologies
│
└── Arch Linux
└── Advanced users, development, customization, learning
The choice of distribution generally depends on factors such as stability requirements, package ecosystem, hardware support, release model, security requirements, enterprise support, management tooling, and the intended workload.
Industry Adoption of Linux
Linux is widely adopted because it provides a combination of performance, flexibility, automation, portability, security, and operational control.
Its major areas of use include:
Linux Industry Adoption
│
├── Servers
│ ├── Web servers
│ ├── Application servers
│ ├── Database systems
│ └── Infrastructure services
│
├── Cloud
│ ├── Virtual machines
│ ├── Cloud infrastructure
│ └── Platform services
│
├── Containers
│ ├── Container runtimes
│ ├── Kubernetes nodes
│ └── Microservices infrastructure
│
├── Networking
│ ├── Routers
│ ├── Firewalls
│ ├── Proxies
│ └── Network appliances
│
├── Embedded / Edge
│ ├── IoT
│ ├── Industrial systems
│ ├── Automotive
│ └── Consumer devices
│
├── High-Performance Computing
│
└── Development / Engineering
├── Software development
├── Automation
├── DevOps
└── Systems engineering
Linux can therefore be understood through five connected layers:
1. Architecture
└── User space ↔ System calls ↔ Kernel ↔ Hardware
2. Kernel
└── CPU, memory, processes, storage, networking, devices, security
3. User Space
└── Libraries, shells, utilities, services, applications
4. Distribution
└── Packaging, repositories, configuration, lifecycle, support
5. Ecosystem
└── Cloud, servers, containers, networking, embedded, HPC, development
These relationships provide the foundation for the practical Linux topics that follow: processes, threads, CPU scheduling, memory, filesystems, storage, networking, permissions, systemd, logging, security, performance analysis, shell scripting, containers, and troubleshooting.
The objective is not to memorize Linux commands. It is to understand which layer is responsible for a behavior, how that layer exposes information, and which tools can be used to observe and modify it.
Terminal Session
# General command syntax
<command_name> [options] [arguments]
[aadarsha@labserver ~]$ touch file1 file2 file3
[aadarsha@labserver ~]$ ls
file1 file2 file3
[aadarsha@labserver ~]$ pwd
/home/aadarsha
[aadarsha@labserver ~]$ ls /
afs boot dev home lib lib64 media mnt opt proc root run sbin srv sys tmp usr var
[aadarsha@labserver ~]$ ls /etc/
adjtime firewalld magic samba
aliases fonts makedumpfile.conf.sample sasl2
...
filesystems machine-id rwtab.d
[aadarsha@labserver ~]$ ls -l /etc
total 1044
-rw-r--r--. 1 root root 16 May 26 15:36 adjtime
-rw-r--r--. 1 root root 1529 Nov 29 2023 aliases
drwxr-xr-x. 2 root root 4096 May 26 15:34 alternatives
-rw-r--r--. 1 root root 541 Jan 14 05:45 anacrontab
drwxr-x---. 4 root root 100 May 26 15:33 audit
drwxr-xr-x. 3 root root 4096 May 26 15:34 authselect
drwxr-xr-x. 2 root root 38 May 26 15:34 bash_completion.d
-rw-r--r--. 1 root root 2709 Nov 29 2023 bashrc
...
...
lrwxrwxrwx. 1 root root 12 Mar 25 05:45 yum.conf -> dnf/dnf.conf
drwxr-xr-x. 2 root root 51 Apr 7 05:45 yum.repos.d
[aadarsha@labserver ~]$ ls -l
total 0
-rw-r--r--. 1 aadarsha aadarsha 0 Jun 4 21:29 file1
-rw-r--r--. 1 aadarsha aadarsha 0 Jun 4 21:29 file2
-rw-r--r--. 1 aadarsha aadarsha 0 Jun 4 21:29 file3
[aadarsha@labserver ~]$ whoami
aadarsha
[aadarsha@labserver ~]$ date
Thu Jun 4 09:33:38 PM +0545 2026
[aadarsha@labserver ~]$ cal
June 2026
Su Mo Tu We Th Fr Sa
1 2 3 4 5 6
7 8 9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30
[root@labserver ~]# date --set=2026-06-01
Mon Jun 1 12:00:00 AM +0545 2026
[root@labserver ~]# date
Mon Jun 1 12:00:03 AM +0545 2026
[root@labserver ~]# date --set=2026-06-04
Thu Jun 4 12:00:00 AM +0545 2026
[root@labserver ~]# date --set=08:13:00
Thu Jun 4 08:13:00 AM +0545 2026
Note:
# date --set changes the system clock and normally requires appropriate privileges.
# Avoid changing the system clock on production systems unless the change is intentional.
[aadarsha@labserver ~]$ ls
file1 file2 file3
[aadarsha@labserver ~]$ mkdir dir1 dir2 dir3
[aadarsha@labserver ~]$ ls
dir1 dir2 dir3 file1 file2 file3
# Running multiple commands at a time
[aadarsha@labserver ~]$ date; cal; ls
Thu Jun 4 09:34:10 PM +0545 2026
June 2026
Su Mo Tu We Th Fr Sa
1 2 3 4 5 6
7 8 9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30
dir1 dir2 dir3 file1 file2 file3
[aadarsha@labserver ~]$ date && cal && ls
Thu Jun 4 09:34:31 PM +0545 2026
June 2026
Su Mo Tu We Th Fr Sa
1 2 3 4 5 6
7 8 9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30
dir1 dir2 dir3 file1 file2 file3
Note:
# ; separates commands that are executed sequentially, regardless of the previous command's exit status.
# && executes the next command only if the preceding command returns an exit status of 0.
[aadarsha@labserver ~]$ date && call && ls && whoami
Thu Jun 4 09:36:56 PM +0545 2026
-bash: call: command not found
# Check the exit status of the last executed command
[aadarsha@labserver ~]$ echo $?
127
# An exit status of 0 conventionally indicates success.
# A non-zero exit status conventionally indicates failure or another non-success condition.
# The exact meaning of a non-zero exit status depends on the command or program.
[aadarsha@labserver ~]$ who
aadarsha tty1 2026-06-04 21:25
aadarsha pts/0 2026-06-04 21:26 (192.168.254.152)
[aadarsha@labserver ~]$ wrongcommand
-bash: wrongcommand: command not found
[aadarsha@labserver ~]$ echo $?
127
[aadarsha@labserver ~]$