EXPERIMENT NO : 11 Dwarkesh

DATE : 23Z431

Study of XV6 Architecture

Xv6 is a simple Unix-like teaching operating system developed by MIT as a successor to the
original Unix operating system. It's used primarily for educational purposes, allowing students to
understand the inner workings of an operating system by studying and modifying its source
code.

The architecture of Xv6 encompasses various aspects, including its kernel design, system call
interface, memory management, file system structure, and process management. Here's a brief
overview of each aspecT v6 is a simple Unix-like teaching operating system developed by MIT
as a successor to the original Unix operating system. It's used primarily for educational
purposes, allowing students to understand the inner workings of an operating system by
studying and modifying its source code.

The architecture of Xv6 encompasses various aspects, including its kernel design, system call
interface, memory management, file system structure, and process management. Here's a brief
overview of each aspect:

1. Kernel Design: Xv6 follows a monolithic kernel design, where all kernel functionalities
reside in a single address space. This design simplifies the implementation and
understanding of the kernel but may lack the modularity and robustness of other kernel
architectures like microkernels.
2. System Call Interface: Xv6 provides a system call interface similar to that of Unix
systems, allowing user programs to request services from the kernel. These services
include file operations, process management, memory management, and I/O operations.
3. Memory Management: Xv6 employs a simple memory management scheme, including
virtual memory management and page-based memory allocation. It typically utilizes a
two-level page table for address translation and supports demand paging for efficient
memory usage.
4. File System Structure: Xv6 implements a simple file system inspired by the Unix File
System (UFS). It supports hierarchical directory structures, file metadata (such as
permissions and timestamps), and various file operations (such as open, read, write, and
close).
5. Process Management: Xv6 manages processes using a traditional fork-exec model. It
supports process creation, scheduling, synchronization, and termination. Additionally,
Xv6 provides basic support for inter-process communication (IPC) through shared
memory and pipes.
Microkernel vs. Monolithic Kernel

The comparison between microkernel and monolithic kernel architectures is fundamental in

understanding different approaches to designing operating systems. Here's a breakdown of
each:

Microkernel:

- In a microkernel architecture, the kernel provides only essential functionalities such as

basic CPU scheduling, inter-process communication (IPC), and memory management.
- Additional services traditionally implemented in the kernel, such as device drivers, file
systems, and network stacks, are moved to user space as separate processes or
servers.
- Microkernels aim to keep the kernel small and modular, which can lead to improved
system reliability, easier maintenance, and better security, as failures in user space
components do not affect the kernel.
- However, the overhead of message passing between user space servers and the kernel
can impact performance, and designing efficient communication mechanisms is crucial.

Monolithic Kernel:

- In a monolithic kernel architecture, all operating system services and device drivers
reside in the kernel's address space.
- This design provides fast communication between kernel components and direct access
to hardware resources, leading to potentially better performance compared to
microkernels.
- However, monolithic kernels tend to be larger and more complex, making them harder to
understand, maintain, and extend.
- Additionally, a bug or failure in any part of the kernel can potentially crash the entire
system, reducing overall reliability.

Process Management

In Xv6, process management is a critical aspect of the operating system's functionality. Xv6
follows a traditional Unix-like process model, with each process represented by a `struct proc`
data structure. Here's an overview of process management in Xv6:

1. Process Creation: When Xv6 boots, it initializes the first process, known as the "init process"
or "user init." This process serves as the ancestor of all other user processes. New processes
are created using the `fork()` system call, which creates a new child process that is a duplicate
of the calling process.

2. Process Termination: Processes can terminate voluntarily by calling the `exit()` system call
or involuntarily due to errors or signals. When a process terminates, it releases its allocated
resources, such as memory and file descriptors, and notifies its parent process of its termination
status.
3. Process Scheduling: Xv6 uses a simple round-robin scheduler to manage CPU scheduling.
Each process is assigned a fixed time quantum during which it can execute before being
preempted and placed back into the ready queue. The scheduler selects the next process to run
based on its scheduling algorithm, typically FIFO or priority-based.

4. Context Switching: When the scheduler selects a new process to run, a context switch
occurs. During a context switch, the state of the currently running process is saved (registers,
program counter, stack pointer, etc.), and the state of the next process to run is restored.
Context switching is a fundamental operation for multitasking and is crucial for efficient process
management.

5. Process States: Processes in Xv6 can be in one of several states:

- Running: The process is currently executing on the CPU.

- Runnable/Ready: The process is ready to execute but is waiting for CPU time.

- Sleeping: The process is waiting for a specific event (such as I/O completion) to occur.

- Zombie: The process has terminated but has not yet been reaped by its parent process.

- Unused: The process table entry is unused and available for allocation.

6. Process Synchronization: Xv6 provides synchronization mechanisms such as locks,

semaphores, and condition variables for coordinating access to shared resources among
multiple processes. These mechanisms help prevent race conditions and ensure proper
synchronization between concurrent processes.

7. Inter-Process Communication (IPC): Xv6 supports IPC mechanisms such as pipes and
message passing for communication between processes. Pipes allow processes to
communicate by reading from and writing to a shared pipe buffer, while message passing
involves sending and receiving messages between processes.

System Call Interface

The System Call Interface in xv6

The system call interface acts as a bridge between user programs and the xv6 kernel. It allows
user programs to request services from the operating system that they cannot perform on their
own, such as accessing hardware devices or managing files. Here's a detailed breakdown of
this interface in xv6:
Components:

● System Calls: These are functions defined in the kernel that user programs can invoke.
xv6 provides a set of core system calls for essential functionalities like process
management, memory management, file I/O, and device interaction.
● System Call Table: This table, typically stored in syscall.h, maps system call
numbers to their corresponding kernel functions. User programs use these numbers to
identify the desired system call.
● User-Space Trap Instruction: A special instruction (e.g., int 0x80 on x86) triggers a
trap into the kernel, initiating the system call mechanism.

Memory Management

● xv6 utilizes paging for memory management, providing processes with isolated virtual
address spaces. Here's a concise breakdown:
○ Virtual Memory: Processes see a larger virtual address space than the physical
memory available. This allows efficient memory allocation and protects
processes from each other.
●
● Page Size: Memory is divided into fixed-size blocks called pages (typically 4KB in xv6).
● Page Tables: Each process has a page table that translates virtual addresses used by
the program into physical memory addresses. The table maps virtual page numbers to
physical frame numbers.
● Memory Management Unit (MMU): This hardware component translates virtual
addresses to physical addresses using the page table information provided by the
kernel.
● No Demand Paging: Unlike some systems, xv6 doesn't use demand paging. This
means all valid pages of a process must be allocated physical pages upfront, even if not
actively used.

File System Structure

The xv6 file system offers a simplified yet functional approach to file organization. Here's a
breakdown of its key components:

1. Inodes (Index Nodes):

● Inodes are the heart of the xv6 file system. They act as metadata holders, storing
information about a file, such as:
○ File size
○ File type (regular file, directory, etc.)
○ Ownership and permissions
○ Time stamps (creation, modification, access)
○ Pointers to data blocks: These pointers don't directly hold the file data but
rather point to the disk locations where the data resides.
2. Data Blocks:

● Data blocks store the actual content of a file.

● xv6 typically uses a fixed size for data blocks (e.g., 512 bytes).
● An inode can point to multiple data blocks using a linking scheme (often direct or indirect
blocks) to accommodate larger files.

3. Directories:

● Directories are special files that organize other files and subdirectories.
● They contain entries, each consisting of:
○ File name (used for user-level access)
○ Inode number (linking the entry to its corresponding inode)
● Special entries like "." (current directory) and ".." (parent directory) help navigate the
directory hierarchy.