CASE STUDY: PINT OS AND ITS KERNAL

MODIFICATION

Submitted By Submitted
To:
Mausam Kumar Shah (077BEI023) Department of
Rohan Bade (077BEI036)
Electronics and
Rajesh Subedi (077BEI032) Computer
Engineering
1.ABSTRACT:
Pint OS, a minimalist and pedagogical operating system, exemplifies the
foundational principles of computer science and operating system design. This case
study offers a comprehensive exploration of Pint OS, from its inception to its
unique architecture and its educational significance. By dissecting its core
components, system structure, and its role in computer science education, this
study illuminates the valuable insights that Pint OS imparts to aspiring software
engineers and operating system enthusiasts. Furthermore, it highlights how Pint OS
serves as a learning tool, demystifying complex concepts and fostering a deeper
understanding of low-level computing. Pint OS stands as a testament to the power
of simplicity in education and its enduring impact on the world of operating
systems and computer science pedagogy.

2.INTRODUCTION:
PintOS is an educational operating system framework developed at Stanford
University, primarily for instructional purposes. Unlike production-grade operating
systems, PintOS is tailored to serve as a practical learning tool for students,
allowing them to delve into the intricacies of operating system design and
implementation in a controlled and educational environment.PintOS comprises
various essential operating system components, including a kernel, file system,
virtual memory system, and support for user programs. What distinguishes PintOS
is its modularity, as students are encouraged to actively engage in implementing
and extending these components. This hands-on approach fosters a deep
comprehension of how these elements collaborate to create a functioning operating
system.PintOS is predominantly implemented in the C programming language.
This choice of language ensures accessibility, as C is a widely taught and
foundational language in computer science. By using C, PintOS facilitates a focus
on operating system concepts without the distraction of complex language
intricacies or platform-specific details.
Despite its simplified nature, PintOS equips students with skills and knowledge
that are directly transferable to real-world operating systems like Linux, Windows,
and macOS. Understanding the inner workings of PintOS serves as a valuable
foundation.
Fig: pintOS architecture

3.KERNAL OVERVIEW:
The kernel of the Pint OS operating system serves as its central nervous system,
orchestrating the essential functions required to manage computer resources and
execute tasks. Here's a closer look at the Pint OS kernel and what it does:

3.1. PROCESS MANAGEMENT:

Process management in Pint OS is a critical component of its kernel's
functionality. It involves overseeing and controlling the execution of individual
tasks or programs, known as processes, on the computer. Here's a detailed
description of process management in Pint OS:
3.1.1. Process Creation and Termination:
Pint OS allows users and applications to create new processes. When a new
program is launched, Pint OS's kernel creates a corresponding process to manage
it. Conversely, when a process finishes its task or is no longer needed, the kernel
terminates it to free up system resources.

3.1.2. Process Scheduling:

Pint OS's kernel is responsible for determining which process gets to use the CPU
and for how long. It uses scheduling algorithms to make these decisions. This
ensures that multiple processes can run on the computer concurrently, giving the
illusion of multitasking.

3.1.3. Context Switching:

When the kernel switches from executing one process to another, it performs a
context switch. This involves saving the current process's state (such as registers
and program counter) and loading the state of the next process. Context switching
is a crucial mechanism for efficient multitasking.
3.1.4. Process Communication:
In a multitasking environment, processes often need to communicate with each
other. Pint OS provides mechanisms for processes to share data or synchronize
their activities, such as through inter-process communication (IPC) mechanisms
like pipes or message passing.
3.1.5. Process Priority and Scheduling Policies:
Pint OS allows processes to have different priorities. Processes with higher
priorities are scheduled to run more frequently, which is especially important in
real-time systems. The kernel manages these priorities and adheres to scheduling
policies to ensure fairness and efficiency.

3.1.6. Process States:

Processes in OS can be in different states, including running, ready, and blocked.
The kernel keeps track of these states to manage the execution of processes
effectively. For example, a process may be waiting for user input (blocked), and
the kernel must handle this appropriately.
3.1.7. Process Termination and Cleanup:
When a process terminates, the kernel ensures that all resources allocated to that
process, such as memory and open files, are properly released. This prevents
resource leaks and maintains system stability.

3.1.8. Error Handling:

The kernel manages errors that can occur during process execution, such as
segmentation faults or illegal instructions. It ensures that processes are terminated
gracefully in the event of critical errors, preventing system crashes.

3.2 MEMORY MANAGEMENT:

Memory management is a fundamental aspect of the Pint OS kernel, ensuring that
the computer's memory resources are efficiently utilized and protected. Here's a
detailed description of memory management in Pint OS:

3.2.1. Memory Allocation:

OS's kernel is responsible for allocating memory to various processes and system
components. When a process is created, the kernel assigns a portion of the
computer's memory to it, providing a protected space for the process to work
without interfering with other processes.

3.2.2. Memory Protection:

To maintain system stability and security, Pint OS enforces memory protection.
This means that one process cannot access or modify the memory allocated to
another process without proper authorization. The kernel prevents unauthorized
access, ensuring the integrity of each process's data.
3.2.3. Address Space Management:
Pint OS manages the virtual address spaces of processes. It maps the logical
(virtual) addresses used by programs to the physical memory locations where data
is stored. This abstraction allows processes to run independently, unaware of the
actual physical memory layout.

3.2.4. Memory Deallocation:

When a process completes its execution or is terminated, the kernel deallocates the
memory it was using. This recycling of memory ensures that available memory is
continuously reused, preventing memory exhaustion.

3.2.5. Memory Paging and Swapping:

Pint OS may use memory paging and swapping mechanisms to efficiently manage
memory. Paging involves dividing physical memory into fixed-size blocks (pages),
while swapping temporarily moves inactive portions of processes' memory to disk
to free up physical RAM.
3.2.6. Memory Fragmentation:
Pint OS tackles memory fragmentation, which can lead to inefficient memory use.
Fragmentation can be internal (unused memory within allocated blocks) or external
(unused memory scattered throughout the system). The kernel employs strategies
to mitigate fragmentation, such as compaction or memory allocation algorithms.

3.2.7. Shared Memory:

In some cases, processes need to share memory for efficient communication. Pint
OS provides mechanisms for processes to establish shared memory regions,
enabling them to exchange data without copying it between their address spaces.

3.2.8. Virtual Memory:

Pint OS may incorporate virtual memory, which extends the computer's physical
memory by using disk storage as an extension. Virtual memory allows processes to
use more memory than physically available, enhancing multitasking and overall
system performance.

e.
3.2.9. Page Replacement:
In systems with virtual memory, OS employs page replacement algorithms to
decide which pages to swap between physical memory and disk like LRU,
LFU,FIFO, optimal page replacement. Commonly used algorithms include Least
Recently Used (LRU) and First-In-First-Out (FIFO).

3.3 FILE MANAGEMENT:

File system management is a vital component of operating systems, responsible for
organizing, storing, and retrieving data efficiently on computer storage devices.It is
the set of procedures and software components within an operating system that are
responsible for the creation, organization, storage, retrieval, and manipulation of
files and directories on storage devices like hard drives, solid-state drives (SSDs),
and external storage media. Here's an overview of file system management in
operating systems:

3.3.1. File Hierarchy:

The hierarchical organization of files and directories simplifies data storage and
retrieval, allowing users to logically structure their data. This hierarchy is crucial
for maintaining order and easy access to files.
3.3.2. File Operations:
Fundamental file operations like creating, reading, writing, deleting, and renaming
files are essential for users and applications to interact with data stored on disk.
These operations form the foundation of file system management.

3.3.3. File Access Permissions:

Security is paramount in file system management. Access permissions control who
can read, write, or execute specific files, safeguarding sensitive data and
preventing unauthorized access.

3.3.4. File Systems and Formats:

Different file systems come with various formats and features. The choice of a file
system impacts data storage capabilities, performance, and compatibility with
different platforms and applications. For example, if you format a USB drive,
you're telling it how to arrange data so your computer can understand it. It's a bit
like deciding whether your digital bookshelf should organize books by title, author,
or genre. Different formats have different rules, and they affect how data is stored
and read on a storage device.

3.3.5. File Metadata:

Metadata, including file attributes and data block addresses, is critical for
efficiently locating and managing files. Metadata provides essential information
about files and helps in optimizing file access.

3.4 SYSTEM CALLS:

System calls in OS are fundamental functions that provide a controlled way for
user-level programs to interact with the kernel and request various operating
system services. These services can include actions like reading and writing files,
creating new processes, managing memory, and more. Here are some common
system calls found in Pint OS:

3.4.1. Create Process:

If we want to start a new program called "my_program" from your current
program. we would use create_process("my_program") to request the creation of a
new process for "my_program."

3.4.2. Read and Write:

Suppose we want to read data from a file called "data.txt" and then write that data
to another file called "output.txt." We would use read(file_descriptor, buffer, size)
to read data and write(output_file_descriptor, buffer, size) to write data.

3.4.3. Opening and closing files:

To work with files, we need to open them first. For instance, we use
open("data.txt", READ_MODE) to open "data.txt" in read mode. After working
with the file, we close it with close(file_descriptor).

3.4.4. Allocate Memory:

Suppose our program needs a block of memory to store some data. we can use
allocate_memory(size) to request memory allocation and get a pointer to the
allocated memory.

3.4.5. Free Memory:

After our program has finished using allocated memory, we should release it with
free_memory(pointer). This ensures that memory is efficiently managed.

3.4.6. Fork:
If our program wants to create a new process that's a copy of itself, we can use
fork(). This new process can then run independently.

3.4.7. Exec:
If our program wants to replace its code and memory with a different program, we
can use exec("new_program"). This effectively starts running "new_program".

3.4.8. Wait:
If our program creates child processes and wants to wait for them to finish before
continuing, we can use wait() to do so.