Methods to pass parameters to OS
If a system call occur, we have to pass parameter to the Kernal part of the Operating system.
For example look at the given open() system call:
C
//function call example#include <fcntl.h>int open(const char *pathname, int flags, mode_t mode); |
Here pathname, flags and mode_t are the parameters.
So it is to be noted that :
- We can’t pass the parameters directly like in an ordinary function call.
- In Kernal mode there is a different way to perform a function call.
So we can’t run it in the normal address space that the process had already created and hence we cant place the parameters in the top of the stack because it is not available to the Kernal of the operating system for processing. so we have to adopt any other methods to pass the parameters to the Kernal of the OS.
We can done it through,
- Passing parameters in registers
- Address of the block is passed as a parameter in a register.
- Parameters are pushed into a stack.
Let us discuss about each points in detail:
1. Passing parameters in registers.
- It is the simplest method among the three
- Here we directly pass the parameters to registers.
- But it will it is limited when, number of parameters are greater than the number of registers.
- Here is the C program code:
C
// Passing parameters in registers. #include <fcntl.h>#include <stdio.h>int main(){ const char* pathname = "example.txt"; int flags = O_RDONLY; mode_t mode = 0644; int fd = open(pathname, flags, mode); // in function call open(), we passed the parameters pathanme,flags,mode to the kernal directly if (fd == -1) { perror("Error opening file"); return 1; } // File operations here... close(fd); return 0;} |
2.Address of the block is passed as parameters
- It can be applied when the number of parameters are greater than the number of registers.
- Parameters are stored in blocks or table.
- The address of the block is passed to a register as a parameter.
- Most commonly used in Linux and Solaris.
- Here is the C program code:
C
//Address of the block is passed as parameters#include <stdio.h>#include <fcntl.h>int main() { const char *pathname = "example.txt"; int flags = O_RDONLY; mode_t mode = 0644; int params[3]; // Block of data(parameters) in array params[0] = (int)pathname; params[1] = flags; params[2] = mode; int fd = syscall(SYS_open, params); // system call if (fd == -1) { perror("Error opening file"); return 1; } // File operations here... close(fd); return 0;} |
3.Parameters are pushed in a stack
- In this method parameters can be pushed in using the program and popped out using the operating system
- So the Kernal can easily access the data by retrieving information from the top of the stack.
- Here is the C program code
C
//parameters are pushed into the stack#include <stdio.h>#include <fcntl.h>#include <unistd.h>int main() { const char *pathname = "example.txt"; int flags = O_RDONLY; mode_t mode = 0644; int fd; asm volatile( "mov %1, %%rdi\n" "mov %2, %%rsi\n" "mov %3, %%rdx\n" "mov $2, %%rax\n" "syscall" : "=a" (fd) : "r" (pathname), "r" (flags), "r" (mode) : "%rdi", "%rsi", "%rdx" ); if (fd == -1) { perror("Error opening file"); return 1; } // File operations here... close(fd); return 0;} |
Introduction of System Call
In computing, a system call is a programmatic way in which a computer program requests a service from the kernel of the operating system it is executed on. A system call is a way for programs to interact with the operating system. A computer program makes a system call when it makes a request to the operating system’s kernel. System call provides the services of the operating system to the user programs via Application Program Interface(API). It provides an interface between a process and an operating system to allow user-level processes to request services of the operating system. System calls are the only entry points into the kernel system. All programs needing resources must use system calls.
A user program can interact with the operating system using a system call. A number of services are requested by the program, and the OS responds by launching a number of systems calls to fulfill the request. A system call can be written in high-level languages like C or Pascal or in assembly language. If a high-level language is used, the operating system may directly invoke system calls, which are predefined functions.
A system call is a mechanism used by programs to request services from the operating system (OS). In simpler terms, it is a way for a program to interact with the underlying system, such as accessing hardware resources or performing privileged operations.
A system call is initiated by the program executing a specific instruction, which triggers a switch to kernel mode, allowing the program to request a service from the OS. The OS then handles the request, performs the necessary operations, and returns the result back to the program.
System calls are essential for the proper functioning of an operating system, as they provide a standardized way for programs to access system resources. Without system calls, each program would need to implement its own methods for accessing hardware and system services, leading to inconsistent and error-prone behavior.