System Calls

System Calls & It's Working

System calls are a fundamental part of the interaction between user-level processes and the kernel in an operating system. They allow user processes to request services provided by the kernel, such as file operations, process management, and hardware access. Switching between user and kernel mode is necessary to maintain security and stability while executing these system calls. Let's dive into these concepts and explore them with examples:

1. System Calls:

• Purpose: System calls are a way for user-level processes to request privileged services from the operating system's kernel.

• Examples:

  • Opening, reading, writing, and closing files (e.g., open, read, write, close).

  • Managing processes (e.g., fork, exec, exit).

  • Allocating and deallocating memory (e.g., malloc, free).

  • Managing devices (e.g., ioctl for device control).

• How it works: When a user process wants to perform an operation that requires kernel privileges, it makes a system call by invoking a specific function or instruction provided by the operating system API.

2. Switching Between User and Kernel Mode:

• Purpose: User and kernel modes exist to separate user-level processes from the privileged operations that only the kernel should perform. Switching between these modes ensures that user processes cannot directly access or modify critical system resources.

• How it is achieved:

  • Hardware Support: Modern CPUs have built-in support for switching between user and kernel modes. They use special CPU instructions, such as syscall or int, to transition between these modes.

  • Context Switch: When a user process makes a system call or encounters an exception, the CPU performs a context switch. This involves saving the state of the user process (registers, program counter, etc.) and loading the state of the kernel.

• Example:

  • Consider the read system call in a Unix-like operating system. When a user-level program invokes read, the CPU switches from user mode to kernel mode, where the kernel reads data from the file and returns it to the user-level program. Once the operation is complete, the CPU switches back to user mode, and the user program continues executing.

  

3. System Call Interface (SCI):

• Purpose: The System Call Interface (SCI) is a set of functions or instructions that provide a bridge between user-level processes and the kernel. It defines how system calls are invoked by user programs and how the kernel should handle these requests.

• Example: In Unix-like systems, the SCI includes C library functions like open, read, write, and close. When a user program calls these functions, they internally invoke the corresponding system call to interact with the kernel.

Example: Reading a File Using the read System Call (Unix-like systems):

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

int main() {
    int fd;  // File descriptor
    char buffer[1024];
    ssize_t bytes_read;

    // Open a file in read-only mode
    fd = open("example.txt", O_RDONLY);

    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    // Read data from the file
    bytes_read = read(fd, buffer, sizeof(buffer));

    if (bytes_read == -1) {
        perror("read");
        close(fd);
        exit(EXIT_FAILURE);
    }

    // Close the file
    close(fd);

    // Process the data
    // ...

    return 0;
}

In this example, the open and read functions are part of the SCI. When read is called, a system call is made to the kernel, which switches to kernel mode to perform the file read operation. Afterward, it switches back to user mode, and the user program continues executing.

Types of System Calls

System calls in an operating system provide a way for user-level processes to request services from the kernel. These services encompass a wide range of operations that interact with hardware, manage processes, access files, and perform other essential tasks. Here are some common types of system calls in an operating system:

1. Process Control:

   • fork(): Create a new process.

   • exec(): Replace the current process with a new one.

   • wait(): Wait for a child process to terminate.

   • exit(): Terminate the current process.

2. File Management:

   • open(): Open a file or create a new one.

   • close(): Close an open file.

   • read(): Read data from a file.

   • write(): Write data to a file.

   • seek(): Move the file pointer to a specific location in a file.

   • rename(): Rename a file.

   • unlink(): Delete a file.

3. Device Management:

   • read(): Read data from a device.

   • write(): Write data to a device.

   • ioctl(): Perform device-specific control operations.

   • open(): Open a device.

   • close(): Close a device.

4. File and Directory Operations:

   • mkdir(): Create a new directory.

   • rmdir(): Remove a directory.

   • chdir(): Change the current working directory.

   • getcwd(): Get the current working directory.

   • stat(): Get information about a file or directory.

   • chmod(): Change file permissions.

   • chown(): Change file ownership.

5. Communication:

   • pipe(): Create a pipe for interprocess communication.

   • socket(): Create a network socket.

   • connect(): Establish a connection to a network socket.

   • send(): Send data over a network socket.

   • recv(): Receive data from a network socket.

6. Time Management:

   • time(): Get the current time.

   • sleep(): Suspend a process for a specified period.

   • alarm(): Set an alarm to receive a signal after a specified time.

7. User and Group Management:

   • getuid(): Get the user ID of the calling process.

   • getgid(): Get the group ID of the calling process.

   • setuid(): Set the user ID of the calling process.

   • setgid(): Set the group ID of the calling process.

8. Memory Management:

   • brk(): Change the end of a process's data segment.

   • mmap(): Map files or devices into memory.

9. Signal Handling:

   • kill(): Send a signal to a process or group of processes.

   • signal(): Set a signal handler for a specific signal.

10. Resource Management:

    • getrlimit(): Get resource limits.

    • setrlimit(): Set resource limits.

11. Networking (Socket API):

    • Functions like bind(), listen(), accept(), and connect() for network socket operations.

These system calls provide a standardized interface for user programs to interact with the underlying operating system and perform various tasks. Different operating systems may have additional or slightly different system calls to support their specific features and functionalities.