Operating System: System Calls

• System calls act as an interface between user-level processes and the operating system kernel.
• They are essential for user programs to request OS services like I/O, memory allocation, and process creation.

Purpose of System Calls

• System calls provide a secure and controlled method for user programs to access kernel resources.
• They abstract hardware and kernel implementation details from user programs.
• System calls ensure system stability and prevent unrestricted hardware access by user programs.

Types of System Calls

• Process management system calls: create, terminate, load, execute, get/set process attributes.
• File management system calls: create, delete, open, close, read, write, get/set file attributes.
• Device management system calls: request, release, read, write, control device.
• Information maintenance system calls: get/set time/date, system data.
• Communication system calls: create/delete communication connection, send/receive messages.
• Protection system calls: set/get file permissions.

How System Calls Work

• A user program initiates a system call, such as reading a file.
• The system call is invoked via a software interrupt or trap instruction.
• The CPU switches from user mode to kernel mode.
• The OS kernel validates the system call and its parameters.
• The kernel executes the requested service.
• The result is returned to the user program.
• The CPU switches back to user mode.

System Call Interface

• System calls are typically accessed through a system call interface provided by the OS.
• C libraries (e.g., glibc on Linux) offer wrapper functions for system calls.
• These wrappers simplify system calls in high-level languages.
• System call numbers identify the specific system call being invoked.

System Call Implementation

• System call implementations reside within the OS kernel.
• Argument validation is crucial to prevent security vulnerabilities and system crashes.
• The kernel services are executed, and data is copied between user and kernel space.
• Error handling is performed, and appropriate error codes are returned.

Examples of System Calls (Linux)

• read(): Reads data from a file descriptor.
• write(): Writes data to a file descriptor.
• open(): Opens a file.
• close(): Closes a file descriptor.
• fork(): Creates a new process (child process).
• execve(): Executes a new program.
• exit(): Terminates a process.
• wait(): Waits for a child process to terminate.
• kill(): Sends a signal to a process.
• mmap(): Maps files or devices into memory.

System Call Overhead

• System calls incur overhead due to the mode switch between user and kernel space.
• Context switching, argument validation, and data copying contribute to the overhead.
• Minimizing the number of system calls can improve performance.

Protection and Security

• System calls are a critical security boundary.
• The kernel must carefully validate system call arguments to prevent privilege escalation.
• Access control mechanisms are used to ensure that processes only access authorized resources.

System Call Tables

• The OS kernel maintains a system call table.
• This table maps system call numbers to corresponding kernel functions.
• When a system call is made, the number is used as an index into this table.
• This helps locate and execute the appropriate kernel function to service the system call.

Monolithic vs. Microkernel

• Monolithic kernels: Most OS services, including system call handlers, run in the kernel space.
• Microkernels: A minimal kernel provides basic services, while other services run in user space.
• In microkernel architectures, system calls might involve message passing between processes.

System Call Arguments

• Arguments passed to system calls must be validated by the kernel.
• Addresses, file descriptors, and other parameters are checked for validity and security.
• Data may need to be copied between user space and kernel space.

Error Handling

• System calls can fail for various reasons.
• The kernel returns an error code to indicate failure.
• User programs must check the return values of system calls and handle errors appropriately.

Relationship to APIs

• APIs (Application Programming Interfaces) often use system calls.
• APIs provide a higher-level, more abstract interface for programmers.
• An API function may make one or more system calls to perform its task.

Virtualization

• In virtualized environments, system calls may be intercepted by the hypervisor.
• The hypervisor either handles the system call or forwards it to the underlying OS.

Performance Considerations

• Frequent system calls can degrade performance due to context switching.
• Alternatives like asynchronous I/O or user-space libraries can reduce system call overhead.

Examples of System Calls (Windows)

• CreateFile(): Creates or opens a file.
• ReadFile(): Reads data from a file.
• WriteFile(): Writes data to a file.
• CloseHandle(): Closes an object handle.
• CreateProcess(): Creates a new process.
• ExitProcess(): Terminates a process.
• WaitForSingleObject(): Waits for an object to enter a signaled state.

How System Calls are Made (x86 Linux)

• The user-level program loads the system call number into the eax register.
• It loads arguments into registers like ebx, ecx, edx, esi, edi, and ebp.
• Executes the int 0x80 instruction (older systems) or syscall instruction (newer systems).
• The kernel takes over, executes the system call, and stores the return value in eax.
• The iret instruction returns control to the user-level program.