6.2. System Calls

A system call is a function that allows user space programs to request services provided by the kernel. This interaction occurs through a well-defined interface where user applications make requests for system services like reading a file, creating a process, or opening a socket for network communication.

A system call serves as a way for programs that run in user space to ask the kernel to perform certain operations. When an application needs to access resources that are managed by the kernel, such as files or memory, it does so by issuing a system call. The kernel then handles these requests and provides the necessary services. This mechanism ensures that all interactions with system resources follow the rules and protection measures established by the kernel.

Imagine you are in a restaurant (user space) and want to order food from the chef (kernel). Instead of going to the kitchen yourself, you tell a waiter (system call) what you want. The waiter communicates your order to the chef and then brings your food back to you. This ensures that you can enjoy your meal without directly interfering in the kitchen.

When a system call is made, the CPU switches from user mode to kernel mode, allowing the kernel to execute privileged operations.

This chunk describes how the system transitions between different modes of operation when a system call occurs. Normally, a CPU operates in user mode, where applications can run without the ability to perform sensitive operations that could crash or compromise the system. When an application makes a system call, the CPU performs a 'context switch' to enter kernel mode, which has higher privileges that enable it to execute the necessary operations on behalf of the application. After the operation is complete, another context switch returns the CPU back to user mode.

Think of a car driving on the road (user mode). The driver must follow traffic rules and cannot do everything they want. But if an emergency arises (making a system call), the driver can ask a police officer (kernel) for special permission to get on the emergency lane until the situation is resolved. After dealing with the situation, the driver returns to normal driving (user mode).

Once the kernel completes the requested operation, it switches back to user mode, allowing the user application to continue its execution.

After the kernel has finished processing the request that originated from the user application, it needs to switch back to user mode. This is crucial because post-operation, the application must be able to resume its task in the same way it was working prior to the system call. The transition back ensures that the application can continue to function normally, using the results provided by the kernel.

Let’s say you called your friend over to ask for help with your homework. After discussing the problem (kernel processing the system call), your friend leaves the room, and you continue working on your homework. You were only assisted temporarily with a specific task and then returned to your activities.

A user application can call the open() system call to open a file, read() to read data from the file, and write() to write data to the file. These system calls allow the application to interact with the kernel's file system.

System calls like open(), read(), and write() are fundamental operations that allow user applications to manage files. The open() call is used to access a file, read() is for retrieving data from the file, and write() is used to save data to the file. Each of these calls interacts directly with the kernel to ensure that the correct file is opened, data is read securely and accurately, and data is written properly with consideration of permissions and file integrity.

Consider opening a book (open()) to read a specific page (read()), and then taking notes in that book (write()). Just as you need to first open the book before reading or writing, programs must make system calls to access files before they can retrieve or store information.

--