Linux系统调用参数传递存疑：寄存器传参为何与asmlinkage定义矛盾？

Great question—this is such a common "wait, that contradicts itself!" moment when diving into Linux kernel internals, so let's break it down step by step to clear up the confusion.

First, let's get straight what each piece actually means:

1. What asmlinkage does #

The asmlinkage attribute is a GCC-specific directive that tells the compiler: "Don’t look for any parameters in registers—read all function arguments exclusively from the stack". This is non-negotiable for kernel functions called directly from assembly (like system call handlers), since assembly enforces strict stack layouts without relying on compiler register conventions.

2. The full flow that resolves the contradiction #

Here's the step-by-step process that connects register-based parameter passing to asmlinkage:

• User-space setup: When a program triggers a system call (e.g., via int 0x80 on x86-32), it loads the system call number into eax, and the first five parameters into ebx, ecx, edx, esi, edi respectively. This is the "register passing" Robert Love references—it's how user space hands off arguments to the kernel's entry point.
• Kernel entry (assembly layer): Once the CPU switches to kernel mode, the entry assembly code (found in arch/x86/kernel/entry_32.S for x86-32) saves all relevant registers onto the kernel stack. That includes copying the values from ebx, ecx, etc., into the stack frame of the upcoming system call handler.
• Calling the C handler: The assembly then jumps to the actual system call implementation (like sys_open or sys_read), which is marked with asmlinkage. Since the compiler knows to read parameters from the stack, it picks up exactly the values that were just copied from the registers.

3. Why this two-step approach is efficient #

Your hunch about efficiency is totally on target! Using registers for the initial handoff from user space to kernel is faster than using the user-space stack:

• Accessing registers is a CPU-native operation with zero memory overhead.
• If parameters were stored in the user-space stack, the kernel would have to perform extra safety checks (to validate the user memory is accessible) and copy the data into kernel memory—adding unnecessary latency.
  By first passing via registers and then copying to the kernel stack, we get the best of both worlds: fast initial argument transfer, and compliance with the asmlinkage convention that keeps C-level kernel code clean and portable across architectures.

To wrap up #

The "register passing" describes how user space delivers parameters to the kernel's assembly entry point. The asmlinkage describes how the C-level system call handlers receive those parameters (from the kernel stack). The assembly layer acts as the bridge between the two, copying register values to the stack before invoking the C function.

内容的提问来源于stack exchange，提问作者ng.newbie