系统调用接口的具体定义是什么？相关概念疑问咨询

Great question—this is a super common point of confusion because the lines between system calls, wrapper functions, and the "system call interface" are often blurred in textbooks. Let’s break this down step by step:

First, Let’s Define the Core Pieces #

• Actual System Calls: These are the low-level, kernel-side functions that handle privileged operations (like opening a file, spawning a process, or accessing hardware). User-space programs can’t call them directly—they need a way to trigger a switch from user mode to kernel mode (via CPU instructions like syscall on x86_64 or svc on ARM).

• Wrapper Functions (e.g., libc’s open()): These are user-space library functions that act as middlemen. They take your high-level C code arguments, package them according to the kernel’s rules (like loading parameters into specific registers), trigger the mode switch to invoke the kernel’s system call, then clean up and return the result in a format your C program expects.

So, What Is the System Call Interface? #

The system call interface is not the C library functions themselves. Instead, it’s the standardized set of rules and conventions that defines how user-space programs can communicate with the kernel to request system services. This includes:

• Unique numbers assigned to each system call (e.g., open is syscall number 2 on many Linux systems)
• Rules for how to pass arguments to the kernel (register usage, stack layout, etc.)
• How to signal the kernel that a system call is being requested (via special CPU instructions)
• The format of return values and error codes

The libc open() function is just one implementation of this interface for C programs. It follows the kernel’s system call interface rules to translate your C code into a valid kernel request.

A Quick Example to Make It Concrete #

When you write:

int fd = open("myfile.txt", O_RDONLY);

1. You’re calling libc’s open() wrapper function, not the kernel’s system call directly.
2. The wrapper loads the syscall number for open into a register, along with the pointer to "myfile.txt" and the O_RDONLY flag.
3. It executes the syscall instruction, which switches the CPU to kernel mode.
4. The kernel looks up the syscall number, runs the internal sys_open function (the actual system call implementation), and returns a file descriptor (or error code).
5. The wrapper takes that kernel return value, converts it to a C int, and passes it back to your program as fd.

One Last Clarification #

The system call interface is kernel-specific, but it’s not tied to C. Other languages (Python, Rust, Go) have their own ways to invoke system calls—either via their standard libraries or direct syscall functions—but they all follow the same underlying system call interface rules defined by the kernel.

内容的提问来源于stack exchange，提问作者Fabio