What are System Calls in OS?

System calls in an operating system are the mechanisms through which programs interact with the kernel. It is through system calls that programs access the hardware, files, and memory, and many other resources. As a beginner, understanding their significance and how they differ from regular function calls can be confusing. In this article, we will discuss what is system call in operating system, how it works, its types, advantages and disadvantages, methods to pass parameters in OS, and the comparison between system calls and interrupts.

Table of Contents:

• What is System Call in Operating System?
• How do System Calls in Operating System work
• System Calls vs Interrupts
• Types of System Calls in Operating System
• Some common System calls in Windows and Linux
• Parameters of System Calls in Operating System
• Methods to Pass Parameters to OS
• Advantages of System Calls in Operating System
• Disadvantages of System Calls in Operating System
• Difference Between System Calls and API Calls
• Conclusion

What is System Call in Operating System?

System call in OS is a mechanism to access the kernel, which operates in kernel mode. It provides the services of the operating system, like reading from a file, to user-space programs via an API without accessing system resources directly.

System calls provide an abstraction layer between the system components, like the CPU and memory, and user programs. They also act as a security mechanism, protecting the system from accidental errors and malicious attacks originating from other programs.

Fast-Track Your Software Engineering Career!

Enroll Now and gain hands-on experience and a prestigious certification to elevate your career!

Explore Program

Services Provided by System Calls in OS

A system call in operating system provides many services. Some of the common features are:

• Process creation and management
• Main memory management
• File Access, Directory, and File Handling
• Device handling (I/O)
• Protection
• Networking and many more

Features of System Calls in OS

The features of system calls in operating system include

• System calls in OS provide an interface between the user and the kernel of the operating system.
• They perform a context switch in the CPU from user mode to kernel mode and execute processes.
• When a service requested by the program fails, the system call returns an error code, which the program can use to display an appropriate error message..
• System calls in operating systems provide a protection mechanism for the privileged operations that protect the system from unauthorized access and attacks.

How do System Calls in Operating System work

You write a program, you give the command to run it, it gets executed, and the output is shown on the screen. The process appears to be fast and straightforward, but it is quite complex. A few more steps are going on in the background that most beginner programmers are not aware of. These steps are called system calls in operating system. It is the way a program or a process interacts with the kernel, which executes it. When the program is completely coded, the user initiates the execution of the process. When you run the compiled file using commands like ./myfile, the shell, which is a program itself, makes a system call to the kernel. Then, the kernel in the operating system executes the program and gives control to the parent process, often the shell, and the shell gives control back to the user. They make context switches from user mode to kernel mode.

Let’s explore how a program interacts with the kernel using system calls. We will take an example of a C program file named myfile.c. This program is to be run on a Linux system.

1. When you run your C program using ./myfile in the terminal, the shell, a user-space program itself, doesn’t directly run your program. The shell makes a system call to the kernel using execve. It tells the kernel to load your myfile into memory and start executing it.
2. Suppose your program needs to open a file. In C, you might write FILE *file = fopen(“example.txt”, “r”);. fopen() is not a system call in itself; it is a standard library function provided by C, which has functions with easy-to-remember names for the user.
3. fopen() will make a system call to the kernel using the SYS_open command. This system call passes the filename and desired mode to the kernel. A context switch occurs; the CPU switches from user mode to kernel mode.
4. Kernel mode has full access to the hardware. The kernel then verifies the request and performs the low-level operation of opening the file on your behalf.
5. After the kernel successfully opens the file, it returns a file descriptor, which is an integer ID for the opened file, to your program. Another context switch occurs, and the CPU switches from kernel mode to user mode.
6. Your program continues its execution from where it left off, now with the file successfully opened.
7. When your program finishes execution, it makes another system call, exit_group, to inform the kernel that it has completely executed. The kernel then manages and cleans up the resources used in the program.
8. Then, the kernel gives control back to the program’s parent process, in this case the shell, which presents the command prompt back to the user and is ready for the next command.

Interrupts vs System Calls in Operating System

Learners and students who are new to the operating system concepts often confuse system calls and interrupts. On learning the primary function of both, they use them interchangeably, thinking the two are the same, but they are not. They might be similar, but they are different from each other based on many factors. Below is a table highlighting those differences.

Types of System Calls in Operating System

All the system calls in OS can be divided into five broad categories. Let us explore all these categories briefly.

1. Process Control: The process that creates the new process is called the parent process, and the newly created process is called the child process. The system calls in this category handle all the commands related to process management, like creating, exiting, and terminating a process, and many more.
2. File management: These system calls in OS handle the operations related to a file, like creating, opening, loading, writing a file, and many more.
3. Device management: The system calls for device management in OS are responsible for requesting and releasing a hardware device, repositioning the location from where read and write can happen, mounting and unmounting external devices to the system, and many more device-related system calls.
4. Information maintenance: These system calls set and fetch the information for system, process, file, or device attributes. It manages the information in the systems and is responsible for changing it.
5. Interprocess Communications: These system calls in OS allow processes to exchange information between them and therefore communicate. This is the process of establishing communication between processes is called inter-process communication, or IPC.

Some Common System Calls in Windows and Linux

These are some of the common system calls used in Windows and Linux in operating systems that you use more than you realize. This table covers a few of the system calls in OS.

Parameters of System Calls in Operating System

The functions of System calls in OS require specific parameters, like any other function in programming. It is these parameters that provide the kernel with all the necessary information required to execute the requested service. The parameters include details like

• The specific operation to be performed (like creating a file or reading data).
• The target on which the operation is to be performed (like the filename, the process ID).
• And finally, the values such as the memory address of a buffer to read into, the number of bytes to write, or specific flags or modes.

When a program in user space performs a system call, it first prepares the parameters of that particular system call. These parameters are usually placed in specific CPU registers or pushed onto the user-space program stack. Then, a system call instruction transfers control to the kernel, which accesses the locations for parameters of the system call to perform the requested task.

System performance depends on how efficiently these parameters are passed between the user and kernel spaces.

Methods to Pass Parameters to OS

User-space programs and the kernel both operate in different memory spaces due to security and isolation. When the kernel is in kernel mode, it can safely access known regions of memory belonging to the user process. A user program cannot directly write to kernel memory or execute privileged kernel operations.

For a system call to be effective, the kernel must get the necessary information from the user process, and the parameter-passing techniques are used. When the CPU switches into kernel mode for a system call, the kernel gains the ability to safely access and read a particular and verified part of the memory of the user process.

Therefore, parameters are passed using well-defined mechanisms that bridge this user-kernel boundary. Let us look at each of these mechanisms in detail with examples.

1. Passing Parameters in Registers

This method is the fastest way to pass parameters to the OS. In this method, the calling program, which is the program that has initiated the system call, places a few parameters (fewer than the number of registers) directly into the CPU registers when the system call is invoked.

Output:

Explanation: In the code above, the parameters fileName, accessMode, and permissions are passed to the open() system call. Internally, these arguments are placed into specific CPU registers before the kernel handles the request.

2. Passing Parameters in Stack

In this method, the calling program pushes the parameters onto the user-space stack. This way, the kernel can easily access the data by retrieving information from the top of the stack. When the system call occurs and the CPU switches to kernel mode, the kernel can then access and read these parameters directly from the user’s stack. While the kernel reads the parameters, the cleanup of the stack frame is handled by the user-space calling convention.

Output:

Explanation: Although abstracted in C, parameters to write() are pushed onto the stack before the system call is made, and the kernel reads them post mode-switch.

3. Passing Parameters to Block or Table in Memory

When the number of parameters is greater than the number of registers, this method is applied. The parameters are stored in blocks or tables, and then the memory address is saved in the registers as a parameter.

Dummy File: example.txt

Output:

Explanation: The stat() call passes a pointer to a memory block (structure) in a register. The actual data is in memory, not directly passed through registers or the stack.

Advantages of System Calls in Operating System

• Due to system calls, programs are able to access hardware devices like printers, disk drives, device drivers, network devices, and more.
• System calls in OS make inter-process communication possible. They allow programs to create and terminate processes.
• They help programs allocate and deallocate memory. Due to system calls in OS, they are able to access memory-mapped hardware devices.
• System calls in OS provide a way for programs to access fundamental operating system services, such as performing low-level input-output operations with files and devices, and keep them secure as well.
• They provide a consistent interface between the user programs and device operating systems. This makes them compatible across all hardware devices and operating system versions.

Disadvantages of System Calls in Operating System

• Each system call involves a transition from user mode to kernel mode, which adds latency. This adds performance overhead because the context switch from kernel mode to user mode slows down the execution of programs.
• Poorly implemented or misused system calls in operating system can expose the system to threats like unauthorized access, privilege escalation, or data leakage.
• Managing errors in system calls, such as memory allocation failures, requires low-level defensive programming. Debugging these issues can be complex, making error handling more challenging.
• Not all operating systems implement system calls in the same way. Developers developing for more than one OS, like Linux and Windows, may need to write separate code or use abstraction layers to maintain portability and compatibility.

Difference Between System Calls and API Calls

Beginners learning about system calls in operating system often confuse system calls and Application Program Interface calls. They are quite different from one another. Here is a table highlighting the primary differences.

Conclusion

In this article, we looked at the concept of system calls in operating systems in detail. We delved into the practical aspects of how they work from the program to the command prompt to the kernel. We also discussed a few of them in Windows and Linux and understood their functions. Understanding system calls in operating systems is fundamental to grasping how an operating system manages the whole computer system and the importance of program-kernel communication.

System Calls in OS (Operating System) – FAQs