Linux for devops | Linux

Linux vs Unix

Linux and Unix are often discussed together because Linux was inspired by Unix, but they have key differences:

Unix

• Developed in 1970s at Bell Labs by Ken Thompson, Dennis Ritchie, and others.

• Originally proprietary and commercial software.

Linux

• Created in 1991 by Linus Torvalds as a free, open-source operating system.

• It was inspired by Unix, but not derived from Unix source code.

Kernel

The kernel is the core component of the Linux operating system. It acts as a bridge between hardware and software, managing system resource and enabling communication between applications and the physical hardware of a computer.

What is the Linux Kernel?

• The kernel is a low-level system software that runs directly on the hardware.

• It provides essential services such as memory management, process scheduling device drivers, and system security.

• It is open-source and developed collaboratively by programmers worldwide, led by Linus Torvalds and the Linux Foundation.

The Linux kernel is a monolithic kernel meaning:

• It contains all the essential operating system service (e.g., process management, memory management, file systems) within a single large program.

• It also supports loadable kernel modules, which allow adding or removing features (like device drivers) without rebooting.

Kernel Architecture

The Linux kernel consists of several layer:

1. Hardware Layer:

• Physical devices (CPU, RAM, disk drivers, etc.) manged by the kernel.

1. Kernel Layer:

• Core of the operating system, implementing all kernel functions.

• Divided into subsystems such as:

  • Process Scheduler: Manages CPU time for processes.

  • Memory Manager: Allocates memory.

  • Device Drivers: Interact with hardware.

  • File System: Handles file storage and access.

  • Network Stack: Manages networking.

1. System Call Interface:

• Provides a gateway for applications to interact with the kernel.

• Applications use system calls to request kernel services.

1. User Space:

• Applications and utilities that run outside the kernel and interact with it using system calls.

Kernel Versions

The Linux kernel is constantly evolving. Versions are released as follows:

• Stable Versions: Officially released and recommended for production use.

• Long-Term Support (LTS): Maintained for several years for enterprise use.

• Development Versions: Contain experimental features and are not recommended for production.

Linux Bootloader

In Linux systems, the bootloader is a crucial part of the boot process. It is responsible for loading the Linux kernel and the initial RAM disk (initrd or initramfs) into memory and starting the operating system.

Role of the Bootloader in Linux

1. Locate the Kernel:

   • The bootloader identifies the Linux kernel (typically a file like vmlinuz) from the boot partition of the storage device.

2. Load the Kernel:

   • The bootloader loads the kernel and, if required, the initial RAM disk (initrd or initramfs) into memory.

   • The kernel is responsible for initializing the system and mounting the root filesystem.

3. Pass Parameters to the Kernel:

   • The bootloader passes boot parameters (kernel arguments) to the Linux kernel, such as the location of the root filesystem, debugging options, or hardware-specific settings.

4. Start the Kernel:

   • Once the kernel is loaded into memory, the bootloader transfers control to it, starting the operating system.

What is a Shell?

• A shell is a program that provides an interface for users to interact with the operating system.

• It can execute commands, run scripts, and manage system resources by communicating with the kernel.

• Shells are typically text-based (CLI), but graphical user interfaces (GUIs) also provide similar functionality.

Types of Shells in Linux

There are many types of shells available in Linux. The most commonly used shells include:

1. Bash (Bourne Again Shell):

   • Default shell in many Linux distributions.

   • Offers scripting capabilities, command history, and tab completion.

2. Sh (Bourne Shell):

   • A simpler shell and the predecessor to Bash.

3. Zsh (Z Shell):

   • An advanced shell with features like improved tab completion, themes, and plugins.

4. Ksh (Korn Shell):

   • Combines features of the Bourne Shell and C Shell, with additional scripting capabilities.

5. Csh (C Shell):

   • Syntax resembles the C programming language.

6. Fish (Friendly Interactive Shell):

   • Focuses on user-friendliness, offering modern features like autosuggestions and syntax highlighting.

How the Shell Works with the Kernel

The shell interacts with the kernel through system calls. Here’s how the relationship works:

1. User Input:

   • The user types a command into the shell (e.g., ls to list directory contents).

2. Shell Interprets the Command:

   • The shell parses the command and determines what the user wants to do.

3. System Calls to the Kernel:

   • The shell translates the command into system calls, which are requests made to the kernel to perform tasks (e.g., accessing files, creating processes).

4. Kernel Executes the Task:

   • The kernel processes the system calls, interacts with the hardware if needed, and completes the requested task (e.g., fetching the file list from disk).

5. Output to the Shell:

   • The kernel sends the output back to the shell, which displays it to the user.

Why is the Shell Important in Linux?

1. User Interaction:

   • The shell is the primary interface for system administration and user interaction in Linux.

2. Flexibility:

   • Users can execute commands, run scripts, and automate tasks efficiently.

3. Powerful Scripting:

   • Advanced scripting capabilities allow automation of complex workflows.

4. Direct Access to System Resources:

   • Through the kernel, the shell provides direct access to system hardware and resources.