STM32 Flash Memory Programming: Firmware Updates and Boot loaders

What Are System Calls?

• System calls act as a bridge between user-space programs and the Linux kernel, enabling applications to request various system services.
• These services cover essential operations such as file handling, process management, memory allocation, inter-process communication (IPC), and networking.
• User programs are restricted from directly interact with the kernel for security and stability reasons. Instead, they use system calls as an interface for accessing these low-level functionalities.

Why Are System Calls Important ?

System calls play a crucial role in system functionality by allowing programs to:

• Interact with Hardware:Applications need system calls to access devices like storage drives, network interfaces, and memory.
• Manage Processes:System calls facilitate process creation, termination, and scheduling.
• Handle Memory Operations:Allocating and freeing memory dynamically requires system calls.
• Ensure Security and Stability:Prevents user programs from directly altering critical kernel data structures, maintaining system integrity.

How Linux System Calls Work?

To Understanding how system calls work in Linux, let’s break the process down step by step:

1. User Program to System Call:

• System calls become available to user program utilization when these programs want to perform specific privileged operations or request kernel services.
• User programs can reach system calls via high-level functions within the C standard library.
• When working in C programming the “open()” function allows users to request file access from the kernel.

Example: Opening a file using open() in C

                       int fd = open(“file.txt”, O_RDONLY);

2. Transition to Kernel Mode:

• A user program must shift from user mode to kernel mode in order to activate system calls.
• User mode applications run by default along with their inherent limitation to system resources to protect security operations.
• The program enters kernel mode upon making a system call to perform hardware interaction and privileged operations.
• A software interrupt together with an exception triggers this movement between user space and kernel space.

3. Identifying the System Call

• The Kernel mode must identify the system call that user programs request.
• User programs identify system calls through their distinct system call number.
• The user program sends this number to the operating system during its request.
• The number 5 serves as the assigned identifier for a system call that performs file opening operations.

                                         Example: System call number for open()

4. Call Table:

• The Linux kernel maintains a system call table, which maps system call numbers to their corresponding functions.
• This table is essentially an array of function pointers, with each entry pointing to a specific system call handler.
  5. Executing the System Call Handler
• The kernel selects the required system call handler after identifying the system call number and allows the handler to execute the requested operation.
• When opening a file the kernel activates the sys_open() system call handler which implements the open() function.

6. Passing Arguments to the Kernel

• System calls often require input parameters, such as filenames, memory addresses, or data buffers.
• Since user-space memory is not directly accessible in kernel mode, the kernel securely copies the arguments into kernel-space memory before execution.

7. Execution of System Call Handler:

• The kernel utilizes the system call number to invoke its corresponding system call handler to execute the defined operation.
• The kernel activates sys_open() which serves as the open() system call handler when a program needs to access files.

8. Return to User Mode:

• Once the system call handler finishes execution, control is returned to user mode.
• The user program resumes operation and can use the result returned by the system call or handle any errors accordingly.

Example: Checking the return value of open()

                     if (fd == -1) {

                              perror(“open failed”);

                          }