Shulou(Shulou.com)06/01 Report--

Xiaobian to share with you the linux system call principle example analysis, I believe most people still do not know how, so share this article for everyone's reference, I hope you have a lot of harvest after reading this article, let's go to understand it together!

The operating system provides services to processes running on it through system calls.

When a user-mode process initiates a system call, the CPU switches to kernel mode and starts executing a kernel function. Kernel functions are responsible for responding to application requests, such as manipulating files, communicating over the network, or requesting memory resources.

For the simplest example, the application process needs to output a line of text and needs to call the write system call:

hello_world.c

#include #include int main(int argc, char *argv[]){ char *msg = "Hello, world!\ n"; write(1, msg, strlen(msg)); return 0;}

annotation

Readers may wonder--isn't the output text a function such as printf?

Indeed. Printf is a higher-level library function, built on system calls, to achieve data formatting and other functions. So, essentially, system calls play a decisive role.

call flow

So what is the flow of invoking a system call within an application?

Let's take a hypothetical system call xyz as an example to describe all the steps of a system call.

As shown in the figure above, the system call execution process is as follows:

Application code calls a system call ( xyz ), which is a library function that wraps system calls;

The library function ( xyz ) is responsible for preparing parameters passed to the kernel and triggering soft interrupts to switch to the kernel;

After CPU is interrupted by soft interrupt, it executes interrupt handling function, namely system call handling function ( system_call );

system call processing function calls the system call service routine ( sys_xyz ) to actually begin processing the system call;

execution state switching

Between the application program and the library function ( libc ), between the system call handler and the system call service routine, are ordinary function calls, which should not be difficult to understand. The library functions and system call processing functions are more complicated due to the switching between user mode and kernel mode.

Linux switches from user mode to kernel mode through soft interrupts. User mode and kernel mode are independent execution streams, so when switching, you need to prepare the execution stack and save registers.

The kernel implements many different system calls (providing different functionality), while the system call handler has only one function. Therefore, the user process must pass a parameter to distinguish, which is the system call number. In Linux, system call numbers are typically passed through the eax register.

To sum up, the execution state switching process is as follows:

The application program is ready to invoke parameters in user mode, and executes int instruction to trigger soft interrupt with interrupt number 0x80;

CPU is interrupted by soft interrupts, the execution of the corresponding interrupt processing function, then has entered the kernel state;

System call processing functions prepare the kernel execution stack and save all registers (usually implemented in assembly language);

The system call processing function calls the corresponding C function according to the system call number--system call service routine;

System call handler functions prepare return values and restore registers from the kernel stack;

System call processing function executes ret instruction to switch back to user mode;

programming practice

Here is a simple program to see how an application prepares parameters in user mode and triggers soft interrupts via int instructions to fall into kernel mode to execute system calls:

hello_world-int.S

.section .rodatamsg: .ascii "Hello, world!\ n".section .text.global _start_start: # call SYS_WRITE movl $4, %eax # push arguments movl $1, %ebx movl $msg, %ecx movl $14, %edx int $0x80 # Call SYS_EXIT movl $1, %eax # push arguments movl $0, %ebx # initiate int $0x80

This is an assembly language program, program entry in the_start tag after.

Line 12, prepare system call number: put constant 4 in register eax. System call number 4 represents the system call SYS_write, which we will use to write a string to standard output.

Lines 14-16 prepare the system call parameters: the first parameter goes into register ebx, the second parameter goes into ecx, and so on.

The write system call requires three parameters:

File descriptor, standard output file descriptor is 1 ;

Write content (buffer) address;

Length of write content (bytes);

On line 17, execution of the int instruction triggers a soft interrupt 0x80, and the program falls into kernel state and the kernel executes system calls. After the system call has been executed, the kernel is responsible for switching back to user mode and the application continues to execute subsequent instructions (starting at line 20).

Lines 20-24 call the exit system call to exit the program.

annotation

Note that the exit system call must be explicitly called here. Otherwise, the program will continue to execute and eventually encounter a segmentation fault!

Readers may be curious-when I write C or other programs, this call is not necessary!

This is because libc has done all the dirty work for you.

Next, we compile and execute this assembly language program:

$ lshello_world-int.S$ as -o hello_world-int.o hello_world-int.S$ lshello_world-int.o hello_world-int.S$ ld -o hello_world-int hello_world-int.o$ lshello_world-int hello_world-int.o hello_world-int.S$ ./ hello_world-intHello, world!

Putting the system call number and call parameters in the right registers and firing the right soft interrupt is a repetitive hassle. Library C has done the dirty work-try the syscall function!

hello_world-syscall.c

#include #include #include int main(int argc, char *argv[]){ char *msg = "Hello, world!\ n"; syscall(SYS_write, 1, msg, strlen(msg)); return 0;} The above is all the content of this article, thank you for reading! I believe that everyone has a certain understanding, hope to share the content to help everyone, if you still want to learn more knowledge, welcome to pay attention to the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.