Submitted to

Engr.Muhammad Shehzad
Deadline: 26 th December 2024
Program: BS-SOFTWARE ENGINEERING
Subject: OPERATING SYSTEM
Semester: 3RD

Section: A

Student’s Name: Linta Naeem (2023-BSE-033)

Hamda Javed(2023-BSE-024)
 Table of Contents
1. Abstract
2. Introduction
a. Definition and Importance of System Calls
3. Concepts of System Calls
a. What is a System Call?
b. System Calls vs. Function Calls
c. Types of System Calls
4. How Do System Calls Work?
a. User Mode and Kernel Mode
b. System Call Interface
c. Examples of Execution
5. Implementation of System Calls
a. Examples in C Programming
b. Code Output and Explanation
6. Real-Life Applications of System Calls
a. File Handling
b. Process Management
c. Network Communication
7. Advantages of System Calls
a. Benefits to System Design
b. Programming Flexibility
8. Drawbacks and Challenges of System Calls
9. Conclusion
 PROJECT REPORT

System Calls in C Language

Abstract
System calls are a fundamental component of modern operating systems, bridging the gap
between user applications and the kernel, which serves as the core of system functionality. They
provide a standardized interface for performing essential tasks such as file management, process
control, memory allocation, and network communication, without exposing sensitive hardware
details or compromising system security.

This report delves into the theoretical and practical aspects of system calls, emphasizing their
critical role in system design and application development. By focusing on examples such as
fork(), read(), write(), wait(), and getpid() in the C programming language, the
report demonstrates how these calls enable robust and efficient operations across diverse
computing scenarios. Additionally, it examines real-world applications, from high-performance
server environments to embedded systems, showcasing their versatility.

The report further explores challenges associated with system calls, such as the overhead of
context switching, synchronization issues in multi-process environments, and platform-specific
variations. Solutions and optimizations, including syscall batching and filtering, are discussed to
address these challenges. This study highlights the pivotal role of system calls in creating
portable, high-performance, and secure applications, offering insights for both novice and
experienced developers.

1. Introduction
In the rapidly evolving landscape of computing, operating systems play a crucial role in
managing resources, executing processes, and facilitating user interactions with hardware. At
the heart of this functionality lies the concept of system calls, which enable controlled
communication between user programs and the kernel. Without system calls, applications
would require direct access to hardware—a process that is both complex and insecure.

Definition of System Calls

A system call is a programmatic interface through which a user-level application requests

services from the operating system kernel. These services include accessing files, allocating
memory, creating processes, managing devices, and facilitating communication between
processes. System calls abstract these operations, providing a safe and efficient mechanism for
performing privileged tasks.

For instance:
 ● The read() system call allows an application to retrieve data from a file or device.
● The fork() system call creates a new process, enabling multitasking.

Through these abstractions, system calls simplify application development and ensure that
sensitive operations remain protected.

The Role of System Calls in Operating Systems

System calls are integral to operating system design, serving several key purposes:

1. Security and Control:

○ System calls provide a controlled interface for accessing hardware and system
resources. By limiting access to kernel space, they prevent malicious or buggy
programs from interfering with critical operations.
○ For instance, the Linux seccomp mechanism allows applications to restrict their
set of permissible system calls, thereby reducing the attack surface.
2. Abstraction:
○ By abstracting hardware-specific details, system calls allow developers to write
code that is portable across different operating systems. For example, POSIX-
compliant system calls like read() and write() function consistently across
Linux, macOS, and Unix systems.
3. Performance Optimization:
○ System calls are designed to provide low-latency access to kernel services.
Techniques such as copy-on-write (used in fork()) and zero-copy I/O (used in
high-speed networking) ensure efficient resource utilization.
4. Flexibility for Developers:
○ Developers can leverage system calls to build robust and flexible applications,
from simple command-line tools to complex, distributed systems. For example,
web servers use fork() to handle multiple client requests simultaneously.

Role of System Calls in Modern Computing

System calls are ubiquitous in contemporary computing, underpinning virtually every

application and service. Examples include:

● File Management: Applications use system calls like open(), read(), write(), and
close() to interact with files and devices.
● Process Control: Multi-process environments rely on system calls such as fork() and
wait() for process creation and synchronization.
● Network Communication: Networked applications, including web servers and chat
programs, depend on system calls like socket() and connect() to establish and
manage connections.
The versatility of system calls makes them integral to fields ranging from operating system
development to application programming.

2. Types of System Calls

System calls are organized into categories based on their functionality. These categories
encompass essential OS services such as process management, file operations, device control,
system monitoring, and inter-process communication.

2.1 Process Control:

Functions that create, execute, and manage processes.

● Examples: fork(), exec(), exit()

● Purpose: Control process life cycles, manage child processes, and enable multitasking.
● Practical Usage:
o fork(): Creates a child process for parallel execution. Often used in web servers
to handle multiple client requests concurrently.
o exec(): Replaces the current process image with a new program, enabling
program execution.

2.2 File Management:

Functions for managing files and directories.

● Examples: open(), read(), write(), close()

● Purpose: Create, read, write, and manipulate file descriptors.
● Practical Usage:
o open(): Opens files and assigns file descriptors for low-level operations.
o write(): Transfers data to files or devices.

2.3 Device Management:

Functions to control devices connected to the system.

● Examples: ioctl(), read(), write()

● Purpose: Request or release control of hardware devices.
● Practical Usage:
o Device drivers use these calls to manage hardware communication.

2.4 Information Maintenance:

Functions that retrieve or modify OS-level information.

● Examples: getpid (), gettimeofday ()

 ● Purpose: Obtain details such as process IDs, system time, and resource usage.
● Practical Usage:
o getpid (): Identifies the calling process for debugging and communication.

2.5 Communication:

Functions that enable data exchange between processes or across networks.

● Examples: pipe(), socket(), shmget()

● Purpose: Support inter-process communication (IPC) and network-based
communication.
● Practical Usage:
o pipe(): Creates a unidirectional communication channel between parent and
child processes.
o socket(): Establishes network connections for data transmission.

How Do System Calls Work?

User Mode and Kernel Mode

System calls allow safe transitions between user and kernel modes, ensuring controlled access to
privileged operations.

How System Calls Work

System calls operate as a gateway between user space and kernel space:

1. User Mode to Kernel Mode Transition:

○ When a system call is invoked, the CPU executes a special instruction (such as
syscall in x86-64) that transitions the program from user mode to kernel mode.
○ This transition allows the kernel to perform the requested operation with elevated
privileges.
2. Execution and Return:
○ The kernel processes the system call, performing the necessary actions (e.g.,
writing data to a file).
○ Upon completion, control is returned to the user program, along with the result of
the operation or an error code.
3. Error Handling:
○ System calls typically return -1 on failure and set the global errno variable to
indicate the specific error. For example, a failed open() call might set errno to
EACCES if the file cannot be accessed due to permission issues.

System Call Workflow

1. The user program invokes a system call via a library function (e.g., read ()).
2. The CPU executes a trap instruction, switching to kernel mode.
 3. The kernel processes the request and performs the necessary operation.
4. Control is returned to the user program, along with a result or error code.

3. Detailed Analysis of System Call Examples

3.1 fork ():

● Purpose: Duplicates the calling process, creating a parent-child relationship.

● Implementation Insight: The child process shares the parent’s memory until
modifications are made (copy-on-write mechanism).
● Use Case: Widely used in multiprocessing environments like server applications, where
new processes handle concurrent requests.

3.2 wait ():

● Purpose: Suspends a parent process until its child process completes execution.
● Key Insight: Provides synchronization, ensuring efficient resource management.
● Use Case: Often combined with fork () to manage process hierarchies.
3.3 write ():

● Purpose: Writes data directly to a file descriptor, bypassing higher-level buffers.

● Key Insight: Allows low-latency data transfer, suitable for real-time logging.
● Use Case: Logging system events or transmitting data over sockets.

Purpose: Reads data from a file descriptor into a user-provided buffer.

3.4 read ():

● Key Insight: Enables efficient low-level input by directly interacting with kernel buffers.
● Implementation Details:
1. The read() call takes three arguments: the file descriptor, a pointer to a buffer,
and the number of bytes to read.
2. The return value indicates the number of bytes successfully read or 0 if the end
of the file is reached.
3. In case of errors, -1 is returned, and errno is set appropriately.
● Use Case:
1. Reading data from files or devices in file-based applications.
2. Streaming content from input sources, such as standard input or sockets.
3.4 getpid ():

● Purpose: Retrieves the process ID of the calling process.

● Key Insight: Crucial for sending signals or tracking execution.
● Use Case: Used in debugging tools to identify misbehaving processes.
4. Usage of System Calls Across Operating Systems

4.1 Linux:

● System Call Interface: Linux provides direct access to fork(), read(), write(), wait(), and
getpid() through system call numbers.
● Examples:
o fork() is used to create new processes.
o read() fetches input from files or devices, while write() outputs data.
o wait() synchronizes parent-child processes.
o getpid() retrieves process IDs for monitoring.

4.2 Windows:

● System Services: Windows abstracts system calls through APIs like Win32.
● Examples:
o fork () is replaced by CreateProcess().
o read () and write () equivalents are ReadFile() and WriteFile().
o getpid () is equivalent to GetCurrentProcessId().

4.3 macOS:

● Unix-Based: macOS supports POSIX system calls like fork(), read(), write(), wait(), and
getpid().
 ● Examples: These calls function similarly to Linux, allowing seamless cross-platform
application development.

4.4 Android:

● Bionic Library: Android’s lightweight C library supports system calls for process
management and I/O.
● Examples:
o read() and write() are used in apps to handle file and network data.
o getpid() is crucial for sandboxing and process isolation.

5. Importance of System Calls

5.1 Security
System calls are essential for maintaining the security of the system by acting as a controlled
interface between user programs and the operating system. For instance:

● read() and write(): They ensure that only the kernel can manage low-level resource
access, preventing unauthorized or unsafe operations.
● fork() and wait(): These calls help with controlled process creation and synchronization,
preventing race conditions and managing resources effectively.
● getpid(): Helps identify processes, ensuring that operations such as signaling or
debugging are securely handled.
These mechanisms prevent direct memory access, ensuring that critical system
operations are protected from unauthorized interference.

5.2 Portability
System calls make applications portable across different platforms by abstracting hardware-
specific details.

● Portability Example: read() and write() behave similarly across Unix-like systems, so
applications can perform I/O tasks without worrying about platform-specific nuances.
By utilizing these standardized system calls, developers can create applications that
work on multiple operating systems with minimal modification.

5.3 Performance
System calls offer low-overhead, direct access to system resources, making operations like
process creation (fork()), synchronization (wait()), and I/O (read(), write()) highly efficient.
 ● Efficient Process Management: fork() and wait() allow for resource-efficient process
creation and management, while copy-on-write optimizations in fork() reduce memory
duplication.
● Fast I/O Operations: read() and write() minimize the need for additional layers of
buffering, which is crucial for performance in applications like databases or streaming
services.

Key Characteristics of System Calls

System calls possess several defining characteristics that differentiate them from regular
function calls:

● Boundary Between User and Kernel Space: Applications execute in user space, a
restricted environment designed to prevent accidental or malicious interference with
the kernel. System calls enable safe transitions between user space and kernel space,
ensuring controlled access to privileged operations.
● Abstraction of Hardware Complexity: System calls abstract the details of interacting
with hardware components, such as disk drives and network interfaces, enabling
developers to focus on application logic rather than low-level hardware interactions.
● Error Handling and Robustness: System calls provide error codes and mechanisms to
handle failures gracefully. For instance, when a read() call encounters an issue, it
returns -1 and sets the global errno variable to indicate the nature of the error.

6. Challenges in System Call Implementation

6.1 Context Switching Overhead

Switching between user mode and kernel mode incurs overhead, especially in I/O-bound
applications that heavily rely on read() and write(). While context switching is necessary for
system stability, it can add latency in high-performance systems.

6.2 Synchronization Issues

In multi-process systems, improper usage of system calls like fork() and wait() can lead to issues
such as race conditions or deadlocks. Managing process synchronization effectively is essential
to avoid these problems.

6.3 Cross-Platform Variations

Differences in system call implementations across operating systems can complicate application
development. For example, fork() might behave slightly differently in Linux and macOS,
requiring developers to ensure compatibility across platforms or use abstraction layers.
Looking ahead, emerging technologies are reshaping how system calls are utilized:

● eBPF (Extended Berkeley Packet Filter): Allows safe execution of custom programs
within the kernel, enabling advanced monitoring and networking capabilities.
● Syscall Filtering: Tools like seccomp enhance security by restricting the set of system
calls an application can invoke.

7. Example: Using fork (), wait (), read (), write (), and getpid ()

Explanation:

1. pipe ():
o A pipe is created to allow communication between the parent and child
processes. The pipefd array holds two file descriptors: pipefd[0] for reading and
pipefd[1] for writing.
2. fork ():
o The fork () system call is used to create a child process. The child process writes
to the pipe, and the parent process reads from it.
3. write ():
o In the child process, the write () system call writes a message into the pipe. The
data is passed from the child process to the parent process.
4. read ():
o The parent process uses the read () system call to retrieve the message from the
pipe that was written by the child process.
5. getpid ():
o Both the parent and child processes call getpid () to print their respective
process IDs, which helps in identifying which process is performing the actions.
6. wait ():
o The parent process calls wait () to ensure it doesn't exit before the child process
has finished its execution, ensuring proper synchronization.

Real-Life Applications of System Calls

System calls are indispensable in various domains:

 ● Web Servers: Use fork() or pthread_create() to handle multiple client requests
concurrently. For instance, Apache and Nginx utilize system calls for process
management and socket communication.
● Databases: Rely on system calls like mmap() for memory-mapped file I/O to achieve
high-speed data retrieval and storage.
● Embedded Systems: Use lightweight system calls to manage limited resources in IoT
devices.
● Containers and Virtualization: Technologies like Docker and Kubernetes rely on system
calls such as clone() and namespace() to create isolated execution environments.

Key Points:

● fork () creates a child process, which performs a separate task.

● write () and read () facilitate inter-process communication through a pipe.
● wait () ensures that the parent process waits for the child to finish.
● getpid () is used to display the process IDs, helping distinguish between parent and
child.
● PIPE_READ is used to refer to the file descriptor for reading from the pipe.
● PIPE_WRITE is used to refer to the file descriptor for writing to the pipe.
8. Conclusion

System calls are an essential component of modern operating systems, providing a bridge
between user applications and the kernel. They enable secure and efficient access to system
resources, allowing developers to perform critical tasks such as file handling, process
management, memory allocation, and network communication. Through system calls,
applications can interact with the operating system in a controlled and standardized way,
ensuring reliability and portability across platforms.

This report has highlighted the importance of system calls, their implementation in C
programming, and their practical applications. It has also addressed the challenges associated
with system calls, such as context-switching overhead, synchronization issues, and platform-
specific variations. By exploring solutions like syscall filtering and optimizations for
performance, this report emphasizes the need for careful use and understanding of system calls
in application development.

In conclusion, system calls remain a fundamental aspect of operating systems, ensuring

security, efficiency, and flexibility. As technology evolves, their role will continue to adapt to
meet new demands, maintaining their importance in enabling robust and reliable computing
systems.

9.Objective of the Report

This report aims to provide a comprehensive overview of system calls, focusing on their
implementation in the C programming language. Through detailed examples, the report
explores the theoretical foundations, practical applications, and challenges associated with
system calls. Key topics include:

● The mechanisms by which system calls enable communication between user space and
kernel space.
● An analysis of common system calls like fork(), read(), and write(), with code
examples and use cases.
● A discussion of real-world scenarios where system calls play a critical role, such as in file
handling, process management, and network communication.
● An exploration of the challenges posed by system call implementation, including
performance overhead and cross-platform compatibility.

By bridging theoretical concepts with practical insights, this report underscores the importance
of system calls in modern computing and provides a foundation for leveraging them effectively
in application development.

10. References for Further Research

● Books:
"Operating System Concepts" by Silberschatz, Galvin, and Gagne.
o
o "Modern Operating Systems" by Andrew S. Tanenbaum.
● Documentation:
o Linux Manual Pages (man 2 read, man 2 write, man 2 fork, man 2 wait, man 2
getpid).
o Official Windows System Services Documentation.
● Web Resources:
o Linux Kernel Documentation.
o GNU C Library Reference.