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

/ * system call * /

(1) what is a system call

The system call is the interface between the kernel and the application. If the application wants to access hardware devices and other operating system resources, it must be completed through the system call.

In linux, system calls are the only means for user space to access the kernel, and they are the only legal entry to the kernel except for exceptions and interrupts. The number of system calls is very small, only about 300 on i386.

(2) the relationship between c library and system call

Application programmers program through the application program interface (API) in the C library rather than directly through system calls. The function in the C library can not call a system call, or it can simply encapsulate a system call, and it can also achieve a function by calling multiple system calls.

Application-- > C library-- > system calls to the kernel

From the programmer's point of view, system calls don't matter, they just need to deal with API.

From the kernel's point of view, the kernel only deals with system calls, and the kernel is not concerned about how library functions and applications use system calls.

Unix's system calls abstract the functions used for a particular purpose, and how to use these functions is the user's business, and the kernel does not care.

(3) system call functions implemented in the kernel

Examples of using system calls in user space

# include getpid ()

After the encapsulation of the glibc library, the function sys_getpid in the kernel/timer.c in the kernel will eventually be called. See the function. All system call functions in the kernel start with sys_.

Asmlinkage informs the compiler, using the local stack to pass parameters, FASTCALL macros to inform the compiler, and registers to pass parameters.

(4) system call number

Because system calls enter kernel space from user space, they cannot be done through simple function calls, but must be done through some special mechanism supported by the processor (so-called soft interrupts).

On x86, this special mechanism is the assembly instruction int $0x80, while on arm, it is the assembly instruction SWI.

This instruction is encapsulated into a function in the C library. When the program executes this instruction, the cpu enters a special exception mode (or soft interrupt mode) and jumps the program pointer to the characteristic position (for example, arm is the 0x8 of the interrupt vector table).

Many system calls are implemented in the kernel, and the addresses of these system calls are placed sequentially in a system call table, which is an array called sys_call_table with a total of NR_syscalls table entries. Through this table, you can call all the sys_ functions defined by the kernel

When you call the assembly instruction int $0x80 or SWI, you pass a system call number, which will be used as an index to select the corresponding system call from the sys_call_table.

Int80 stores the system call number in the eax register, while SWI integrates it directly in instructions (such as SWI 0x124).

(5) the implementation mechanism of system call.

The functions in the kernel that handle system calls are defined in system_call in arch/i386/kernel/entry.s, while arm systems are defined in vector_swi in arch/arm/kernel/entry-common.s. The system call table for x86 systems is defined in arch/i386/kernel/syscall_table.s (or directly in entry.s), while arm is defined in arch/arm/kernel/calls.s and the system call number is defined in include/asm/unistd.h

(6) what should be paid attention to in order to realize the system call?

It is not difficult to add a system call to linux, but how to design and implement a system call is the problem. Linux does not advocate the use of multi-purpose system calls (providing different functions according to different parameters).

The system call must carefully check the validity of the incoming parameters, especially the pointers provided by the user, and must ensure that:

* the memory area that the pointer points to belongs to the user space, and the process cannot cajole the kernel to read the data in the kernel space * the memory area pointed to by the pointer belongs to the address space of the process. Cannot cajole the kernel to read the data of other processes * processes cannot bypass memory access permissions.

The kernel is in the process context when executing system calls, which can be dormant or preempted, so it is necessary to ensure that system calls are reentrant.

(7) an example of a system call (including kernel modification and implementation of user space programs)

Implement a system call sys_foo

a. Add system call number

Modify include/asm/unistd.h, add: # define _ _ NR_foo 289 and modify: # define NR_syscalls 290

b. Add to the system call table

Modify arch/i386/kernel/entry.s or syscall_table.s by adding:

.long sys_foo

c. The system call must be compiled into the kernel image of the core, and the definition of the system call can be placed in the code that is most closely related to its function, such as kernel/sys.c, add:

# include / * * return the size of kernel stack * / asmlinkage long sys_foo (void) {return THREAD_SIZE;}

d. Make a call in user space

Usually, the system call is supported by the c library, and it is impossible for glibc to support our own system call. In this case, we need to access the system call directly with the help of a set of macros provided by linux itself.

Man 2 syscall

Summary

The above is the whole content of this article. I hope the content of this article has a certain reference and learning value for everyone's study or work. Thank you for your support. If you want to know more about it, please see the relevant links below.

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.