How are system calls connected to the operating system?

System calls are the interface between user programs and the operating system kernel. They provide a controlled way for applications to request services from the OS, such as file operations, memory allocation, or hardware access. Application developers typically access system calls through APIs (Application Programming Interfaces), which define how software components should communicate.

When a user program needs to interact with the operating system − whether to read a file, allocate memory, or access hardware − it must use system calls. This mechanism ensures that user programs cannot directly access critical system resources, maintaining security and stability.

User Mode vs Kernel Mode

Programs execute in two distinct modes −

• User mode − Programs have limited privileges and cannot directly access hardware resources. They can only perform user-level operations.

• Kernel mode − The operating system has full access to all hardware resources including RAM, CPU, disk drives, and other peripherals.

The processor switches between these modes depending on what type of code is running. A mode bit indicates the current mode: set to 1 for user mode and 0 for kernel mode. When a program in user mode needs hardware resources, it must make a system call to request kernel services.

How System Calls Work

The transition from user mode to kernel mode occurs when:

• An application makes a system call

• An interrupt occurs (hardware or software)

• An exception happens (like a page fault)

This switching from user mode to kernel mode is called a context switch, which involves saving the current program state and loading the kernel execution environment.

Examples of System Calls

/* File Operations */
open("/path/to/file", READ_ONLY)
read(file_descriptor, buffer, size)
write(file_descriptor, data, size)
close(file_descriptor)

/* Process Management */
fork()          // Create new process
exec()          // Execute program
wait()          // Wait for child process
exit()          // Terminate process

/* Memory Management */
malloc(size)    // Allocate memory
free(pointer)   // Deallocate memory

Key Points

• Security − System calls provide controlled access to system resources

• Abstraction − Programs don't need to know hardware details

• Stability − Kernel mode crashes halt the entire system, while user mode crashes only affect individual programs

• Performance − Context switching has overhead but ensures system protection

Conclusion

System calls are the fundamental bridge between user applications and the operating system kernel. They enable secure, controlled access to system resources while maintaining the separation between user and kernel modes. This mechanism is essential for system stability, security, and proper resource management in modern operating systems.