阿男聊技术

IDT、SYSCALL 与 FRED：三条内核入口，同一份 pt_regs？

最近在看 x86-64 怎么进内核，经常听到四句：硬件中断要查 IDT；syscall 直接用 MSR；进内核后都要构建 pt_regs；FRED 把上面这些都简化了。对照 SDM、FRED 规范和 Linux 源码以后，发现它们在默认路径上只对一半，不能直接套到 FRED 上。在这里把路径捋一下。

一、那四句话怎么说才靠谱

可以这样限定（后面各节展开源码和手册）：

1. 硬件中断 / CPU 异常：默认走 IDT；FRED 启用后走 FRED event delivery，不再查 IDT。
   「查 IDT」指 CPU 按向量读一项门描述符（SDM Vol 3A 约 §6.14）¹，不是内核扫整张表。Linux 启用 FRED 时会 idt_invalidate()，注释写 Any further IDT use is a bug（fred.c）。之后按 type × vector 两级软件分发²，见 fred_entry_from_user()。

2. 64 位 syscall：默认经 STAR/LSTAR/FMASK 入核、不进 IDT；FRED 启用后同一条指令改由 FRED 投递，再落到 do_syscall_64。
   非 FRED 时入口 RIP 来自 IA32_LSTAR¹³。Linux 在 idt_syscall_init() 把 MSR_LSTAR 写成 entry_SYSCALL_64。规范 §3 / §7.4：CR4.FRED=1 时 SYSCALL/SYSENTER 改用 FRED event delivery，返回走 ERETU⁴。Linux 在 fred_other() 里识别 FRED_SYSCALL 后调 do_syscall_64。int $0x80 仍属中断类路径，别和 64 位 syscall 混谈。

3. C 层几乎都拿 pt_regs *，但帧怎么来的不同。
   IDT 靠硬件 IRET 帧再软件补全；传统 SYSCALL 几乎全靠 entry_SYSCALL_64 手工 push；FRED 靠硬件 FRED 帧 + FRED_ENTER。结果同为 struct pt_regs *，过程不能互换叙述。见 ptrace.h。

4. FRED 统一的是事件投递与返回，不是删掉 pt_regs、MSR 或软件分发表。
   规范 §3：原会走 IDT 的事件改走 FRED；SYSCALL/SYSENTER 亦并入；返回用 ERETS/ERETU⁴。Linux 仍保留扩展后的 pt_regs、更多 FRED MSR（cpu_init_fred_exceptions()）、以及 sysvec_table。fred=on|off（on 为默认）见⁵。

压成一句：

非 FRED：中断/异常查 IDT，64 位 syscall 走 MSR，两边都落到（不同构建方式的）pt_regs。** FRED：**统一投递与返回——IDT 作废、SYSCALL 也进 FRED；pt_regs 仍在，MSR 与软件分发仍在。

对照表：

flowchart TB
    subgraph Traditional["传统路径"]
        IRQ1["外部 IRQ / 异常"] --> IDT["IDT 门描述符"]
        SYS1["用户 syscall"] --> MSR["LSTAR / STAR / FMASK"]
        IDT --> PT1["软件补全 pt_regs"]
        MSR --> PT1
    end

    subgraph FredPath["FRED 路径"]
        EVT["任意事件含 SYSCALL"] --> FRED["FRED event delivery"]
        FRED --> DISP["type × vector 软件分发"]
        DISP --> PT2["FRED 帧 + FRED_ENTER"]
    end

二、默认路径：中断查 IDT，syscall 走 MSR

2.1 硬件中断 / CPU 异常 → IDT

不开 FRED 时，外部中断或 CPU 异常大致是：

1. 中断控制器（APIC 等）给出向量号；
2. CPU 用 IDTR → IDT[vector] 读门描述符；
3. 硬件压 IRET 帧（SS、RSP、RFLAGS、CS、RIP；异常可能还有 error code）；
4. 若门描述符 IST ≠ 0，切换到 TSS 中对应 IST 栈。

「查 IDT」是 CPU 按向量索引一项门描述符，不是内核遍历整张表。SDM Vol 3A 大约 §6.14¹。

Linux 里外部 IRQ：

APIC/MSI → 向量 N
    └─ IDT[N] → irq_entries_start + offset（idtentry.h）
        └─ push 向量号（占 orig_ax 槽）→ asm_common_interrupt
            └─ error_entry → PUSH_AND_CLEAR_REGS
                └─ common_interrupt(regs, vector)（irq.c）

参见：idtentry.h · entry_64.S · irq.c

外部 IRQ 与 #PF/#DE 等共用 IDT 机制，但 stub 宏不同（idtentry_irq vs idtentry）。用户态进来的，常经 error_entry + sync_regs 落到线程内核栈上的标准 pt_regs 槽位。

2.2 64 位 SYSCALL → MSR（不进 IDT）

SYSCALL 不查 IDT。硬件把 RIP 换成 MSR_LSTAR、用 RCX/R11 保住返回契约、按 MSR_STAR 推导 CS/SS，并用 IA32_FMASK 掩 RFLAGS——不保存 RSP，也不压完整 IRET 帧¹³。

Linux 在每 CPU 初始化时把 MSR_LSTAR 指到 entry_SYSCALL_64：

// arch/x86/kernel/cpu/common.c:2268-2270
static inline void idt_syscall_init(void)
{
	wrmsrq(MSR_LSTAR, (unsigned long)entry_SYSCALL_64);

入口汇编自己切栈、手工搭 pt_regs：

// arch/x86/entry/entry_64.S:87-121
SYM_CODE_START(entry_SYSCALL_64)
	UNWIND_HINT_ENTRY
	ENDBR

	swapgs
	/* tss.sp2 is scratch space. */
	movq	%rsp, PER_CPU_VAR(cpu_tss_rw + TSS_sp2)
	SWITCH_TO_KERNEL_CR3 scratch_reg=%rsp
	movq	PER_CPU_VAR(cpu_current_top_of_stack), %rsp
	...
	PUSH_AND_CLEAR_REGS rax=$-ENOSYS
	...
	call	do_syscall_64		/* returns with IRQs disabled */

调用链：

用户 syscall 指令
    └─ MSR_LSTAR → entry_SYSCALL_64（entry_64.S:87）
        └─ swapgs；用户 RSP → TSS.sp2；RSP ← cpu_current_top_of_stack
            └─ 手工 push 用户态部分 + PUSH_AND_CLEAR_REGS
                └─ do_syscall_64(regs, nr)（syscall_64.c）

可以看到，MSR 只负责跳到入口；完整 pt_regs 由 entry_SYSCALL_64 软件搭建。这里的 TSS.sp2 只是 scratch，用来暂存用户 RSP——不是 IDT 那套「硬件按 TSS.RSP0 / IST 自动切栈」（见 §4.7）。

其他系统调用入口仍走 IDT：int $0x80（向量 0x80）、ia32 sysenter 等。

2.3 传统路径对照

两边进 C 之前，常见路径都会走 PUSH_AND_CLEAR_REGS（calling.h）：IDT 多经 error_entry，SYSCALL 在 entry_SYSCALL_64 里直接调；走 IST 的 #DF/NMI 等也常经 paranoid_entry，里面同样调这个宏。宏主要是补通用寄存器并清掉；前面往往还有硬件压栈或手工 push，不是单靠它从零搭出整帧。

关于 TSS.RSP0：不是「凡中断/int 都读一遍 sp0」。只有 用户态→ring 0 且门上 IST=0 时硬件才用它切栈；IST≠0 用 TSS.IST[]；已在 ring 0 通常不切 RSP0。Linux 上 RSP0 还多半是 per-CPU entry trampoline，不是该 process 的线程内核栈（§4.7）。

sequenceDiagram
    participant U as 用户态
    participant CPU as CPU
    participant K as 内核入口

    Note over U,K: IDT 路径
    U->>CPU: 异常或外部 IRQ
    CPU->>CPU: 查 IDT 门, 压 IRET 帧
    CPU->>K: 跳门描述符入口
    K->>K: error_entry / PUSH_AND_CLEAR_REGS

    Note over U,K: SYSCALL 路径
    U->>CPU: syscall
    CPU->>CPU: 读 LSTAR 等 MSR, 不压栈帧
    CPU->>K: entry_SYSCALL_64
    K->>K: 切栈并手工构造 pt_regs

三、pt_regs：结果相同，构建方式不同

三条路径的 C ABI 目标一致：handler 收到 struct pt_regs *。但谁压什么不同：

容易踩坑的说法：

• 「syscall 像中断一样由硬件压 IRET 帧」→ SYSCALL 不压完整帧。
• 「进了内核就有完整 pt_regs」→ 是入口汇编 + calling.h 宏搭出来的，不是 C 结构体被硬件 memcpy。
• 「IRQ 向量在某个专用寄存器」→ stub 用 push imm8 占位 orig_ax，C 层再解释为向量号。
• 「FRED 不用 pt_regs」→ 仍用；只是布局扩展了。
• 「IST / #DF 不用 pt_regs」→ 仍要建。IST 只决定压到哪条栈；#DF 虽常已在内核，仍经入口补 pt_regs 再进 exc_double_fault 等。
• 「TSS.RSP0 = 该 userspace process 的内核栈」→ Linux 上通常是 entry 栈，线程栈靠后续软件迁过去。

一句话用途：pt_regs 在内核栈上保存一次进核时的寄存器现场，供中断/异常/系统调用处理，并在返回时恢复。 硬件不认识这个 C 结构体；给 handler 用的完整视图由内核整理，IDT/FRED 可有硬件贡献字节。

ptrace.h 注释写明：FRED 栈帧从 orig_ax 开始，且始终带 error code；cs/ss 槽在 FRED 下可解读为 fred_cs / fred_ss：

// arch/x86/include/asm/ptrace.h:127-163
	/*
	 * orig_ax is used on entry for:
	 * - the syscall number (syscall, sysenter, int80)
	 * - error_code stored by the CPU on traps and exceptions
	 * - the interrupt number for device interrupts
	 *
	 * A FRED stack frame starts here:
	 *   1) It _always_ includes an error code;
	 *   ...
	 */
	unsigned long orig_ax;
	...
	union {
		u16		cs;
		u64		csx;
		struct fred_cs	fred_cs;
	};
	...
	union {
		u16		ss;
		u64		ssx;
		struct fred_ss	fred_ss;
	};

后面 fred_entry_from_user(struct pt_regs *regs)、do_syscall_64(regs, …) 照旧吃这个指针。

四、FRED：统一了什么，没删掉什么

FRED（Flexible Return and Event Delivery）用事件投递 + ERETS/ERETU 替代传统 IDT + IRET⁴²。规范目标包括：用更低延迟的转移替换 IDT 投递与 IRET；投递/返回时一次建全 supervisor/user 上下文。

启用后，凡原先会走 IDT 的事件改走 FRED event delivery；SYSCALL / SYSENTER 的既有操作也被替换为 FRED 投递。返回侧用 ERETU（回 ring 3）与 ERETS（仍在 ring 0）⁴。

统一的是进核/回用户的硬件机制，不是「syscall 也去查 IDT」。 IDT 会被作废。

4.1 Linux 如何启用；开关在 CR4.FRED

两项不要混成「都是编译期参数」：

真正打开硬件机制的是 CR4.FRED。启用顺序：写 FRED MSR → 置 CR4.FRED → idt_invalidate()（作废 IDT，再走 IDT 视为 bug）。

BSP 上常见调用链：setup_arch() → cpu_init_replace_early_idt() → cpu_init_fred_exceptions()；AP 在 cpu_init() 里再配一遍。MSR = Model Specific Register（型号相关寄存器），按编号用 RDMSR/WRMSR 访问。wrmsrq()（asm/msr.h）是内核「写 64 位到某 MSR」的封装，底层就是 WRMSR。

// arch/x86/kernel/fred.c:28-69
void cpu_init_fred_exceptions(void)
{
	...
	wrmsrq(MSR_IA32_FRED_CONFIG,
	       FRED_CONFIG_REDZONE |
	       FRED_CONFIG_INT_STKLVL(0) |
	       FRED_CONFIG_ENTRYPOINT(asm_fred_entrypoint_user));
	...
	cr4_set_bits(X86_CR4_FRED);
	/* Any further IDT use is a bug */
	idt_invalidate();

	/* Use int $0x80 for 32-bit system calls in FRED mode */
	setup_clear_cpu_cap(X86_FEATURE_SYSFAST32);
	setup_clear_cpu_cap(X86_FEATURE_SYSCALL32);
}

idt_invalidate() 把 IDTR 载成空表：

// arch/x86/kernel/idt.c:337-344
void idt_invalidate(void)
{
	static const struct desc_ptr idt = { .address = 0, .size = 0 };

	load_idt(&idt);
}

4.2 syscall / int 仍可用；换的是底层，不是禁指令

启用 FRED 以后，用户态照样可以执行 syscall / sysenter，以及 int n / int3 等——指令还能发，变的是 CPU 进核路径⁴：

返回指令全称：ERETU = Event Return to User（回 ring 3）；ERETS = Event Return to Supervisor（仍在 ring 0）。用户态一般不发 SYSRET；换出口的是内核。

用户态调用约定（64 位）基本不变：仍发 syscall，调用号/RAX、参数寄存器约定照旧，最后仍常进 do_syscall_64。变的是 CPU/内核进核路径与返回指令。32 位：Linux 会清掉快路径 capability，多走 int $0x80。

4.3 FRED 寄存器：自有 MSR，并复用少量旧 MSR

规范：CR4.FRED = 0 才走 existing SYSCALL；= 1 则 FRED event delivery⁴。入口跳转不再靠 LSTAR，但 FRED 不是和传统 syscall「完全另一套、零重叠」——规范 §4.4 写明仍用若干已有 MSR⁴。

对 syscall 投递而言：

FRED 配套状态（规范 §4.2–4.4；PDF 约第 13–15 页）⁴：

与传统 syscall MSR 不是同一套：主用 FRED_* + CR4.FRED；重叠主要是 STAR（CS/SS） 和 GS 相关基址。内核启动时仍可能写过 LSTAR，但 FRED 已开的 CPU 上 syscall 进核不靠它跳。

CPU 定入口：ring 3 事件 RIP = FRED_CONFIG & ~0xFFF；ring 0 事件 = 该页基址 +256。Linux 把页对齐入口放在 asm_fred_entrypoint_user，+256 是 asm_fred_entrypoint_kernel。

4.4 事件分发：统一门口，处理在 C 里

跳进 asm_fred_entrypoint_user 之前，硬件已做完 FRED event delivery（切栈、压 FRED 帧、装 CS/SS/RIP、必要时换 GS）。入口只是软件侧的统一门口：

// arch/x86/entry/entry_64_fred.S:18-45
.macro FRED_ENTER
	PUSH_AND_CLEAR_REGS
	movq	%rsp, %rdi	/* %rdi -> pt_regs */
.endm

.macro FRED_EXIT
	POP_REGS
.endm

SYM_CODE_START_NOALIGN(asm_fred_entrypoint_user)
	FRED_ENTER
	call	fred_entry_from_user
	FRED_EXIT
1:	ERETU

• FRED_ENTER：在硬件帧上补通用寄存器 → pt_regs *
• fred_entry_from_user()（entry_fred.c）：按 type/vector 真正分发和处理
• FRED_EXIT：只做软件侧 POP_REGS（弹出通用寄存器）；真正出核靠后面的返回指令
• ERETU：硬件按 FRED 帧回 ring 3

这几行汇编是用户态事件的统一门口 + 出口，不是把 int/syscall/异常业务全做完——业务在 fred_entry_from_user 及其调用的 handler 里。内核里再发生的事件走 asm_fred_entrypoint_kernel（同页 +256），出口是 ERETS。

fred_entry_from_user() 按 regs->fred_ss.type 做第一级分发：

// arch/x86/entry/entry_fred.c:238-267
__visible noinstr void fred_entry_from_user(struct pt_regs *regs)
{
	unsigned long error_code = regs->orig_ax;
	regs->orig_ax = -1;

	switch (regs->fred_ss.type) {
	case EVENT_TYPE_EXTINT:
		return fred_extint(regs);
	case EVENT_TYPE_NMI:
		...
	case EVENT_TYPE_HWEXC:
		return fred_hwexc(regs, error_code);
	case EVENT_TYPE_SWINT:
		return fred_intx(regs);
	...
	case EVENT_TYPE_OTHER:
		return fred_other(regs);
	default: break;
	}
	return fred_bad_type(regs, error_code);
}

64 位 syscall 在 FRED 下的落点：

// arch/x86/entry/entry_fred.c:78-85
static __always_inline void fred_other(struct pt_regs *regs)
{
	if (likely(regs->fred_ss.vector == FRED_SYSCALL && regs->fred_ss.l)) {
		regs->orig_ax = regs->ax;
		regs->ax = -ENOSYS;
		do_syscall_64(regs, regs->orig_ax);
		return;
	}
	...
}

规范写得很直白：当 CR4.FRED = 1 时，用 FRED event delivery 替换既有 SYSCALL 操作；返回应使用 ERETU 而非 SYSRET（FRED 下 SYSRET 为 #UD）⁴。

因此 FRED 下：

• 执行 syscall，或者来一个硬件中断——门口都是 FRED
• 外部 IRQ：不再由 CPU 查 IDT，但仍按向量软件 dispatch（sysvec_table / common_interrupt）
• 64 位 SYSCALL：不再 LSTAR → entry_SYSCALL_64，改 FRED → fred_other → do_syscall_64
• IST：不再 IDT.IST + TSS.ist[]，改 FRED_RSP0–3 + FRED_STKLVLS

flowchart TD
    A["事件发生"] --> B["FRED event delivery"]
    B --> C["asm_fred_entrypoint_user"]
    C --> D["fred_entry_from_user"]
    D --> E{"fred_ss.type"}
    E -->|EXTINT| F["fred_extint"]
    E -->|HWEXC| G["fred_hwexc"]
    E -->|OTHER| H["fred_other"]
    E -->|NMI 等| I["对应 handler"]
    H -->|FRED_SYSCALL| J["do_syscall_64"]
    F --> K["sysvec_table 或 common_interrupt"]

内核文档把这套分发概括为两级：先按事件类型，再按向量²。

4.5 FRED 并没有「简化掉」的东西

价值在统一投递与返回语义（更低延迟、原子上下文、edata 替代 CR2/DR6 瞬态等），不是删除所有内核数据结构。

4.6 硬件统一了什么；软件仍要做什么

投递与返回这一层是硬件替代；内核仍要做 type × vector 软件分发。

内核侧仍须软件完成：

• 两级分发：硬件只送到 asm_fred_entrypoint_*；再按 fred_ss.type → fred_ss.vector
• pt_regs / 通用寄存器补全：硬件给 FRED 帧；FRED_ENTER 等再补齐
• IDT 表本身：idt_invalidate() 后表不再参与投递——不是换一张 IDT，而是硬件换机制

一句话：FRED 用硬件统一「怎么进 ring 0 / 怎么回」（含原 IDT 事件 + SYSCALL/SYSENTER）；「进核后调哪个 handler」仍是内核软件表。

不是任务切换。 FRED 管的是事件进核/返回（ring 切换），不是 schedule / switch_to 那种进程、线程上下文切换。调度路径照旧。

也可以说：进核之后相对统一（pt_regs → handler → 返回约定）；复杂度主要在切换过程（IDT/RSP0/IST vs MSR vs FRED 投递与栈级别）。FRED 收的是后一层。

4.7 TSS.RSP0 / IST：只属于 IDT 路径；#DF 仍建 pt_regs

TSS.RSP0 / IST 是 IDT（中断/异常/INT n）投递时的硬件切栈机制，传统 64 位 syscall 不走：

SYSCALL 入口里出现的 TSS 字段（如 sp2）只是内核拿 TSS 当 scratch，不是 IDT 那套「硬件按 RSP0/IST 自动切栈」。FRED 启用后，切栈改由 FRED stack level + FRED_RSP*，与旧 IST/RSP0 模型并列替代，而非「给 SYSCALL 补上 RSP0」。

IST 地址存在 TSS.IST[]：门上 IST 字段选槽，硬件从那里取栈顶。#DF 等即使用 IST、且常已在内核，仍会在应急栈上建 pt_regs（常见经 paranoid_entry → PUSH_AND_CLEAR_REGS），不是「内核里 fault 就跳过 pt_regs」。

五、FRED 省了哪些步骤；快在哪里

FRED 不是把 syscall / IDT 路径整段删掉，而是把「进核 / 回用户」换成另一套硬件原语。省下的是旧机制里若干段，不是 do_syscall_64 / common_interrupt 之后的内核业务。

5.1 相对 IDT：少做 / 换掉的

5.2 相对传统 SYSCALL：少做 / 换掉的

do_syscall_64 本身还在，只是前面从 entry_SYSCALL_64 换成 fred_other → 同一条 C 分发。

5.3 并没有「省掉」的

• pt_regs 仍在（布局扩展）
• 软件两级分发（type → vector）——原先 IDT「向量 → 门里的 RIP」有一部分改由软件做
• IRQ / 异常 / syscall 进各自 handler 仍在
• PUSH_AND_CLEAR_REGS 仍在（FRED_ENTER 里也会调）
• 配置更重：更多 FRED MSR

5.4 延迟：对标谁、别指望什么

规范与内核文档写明的目标是：用更低延迟的转移替换 IDT event delivery 和 IRET⁴²。

flowchart LR
    subgraph Win["FRED 延迟目标主要对标"]
        IDT["IDT 查门"] --> IRET["IRET 返回"]
    end

    subgraph Unify["统一进同一模型"]
        SYS["SYSCALL / SYSENTER"]
        IRQ["IRQ / 异常"]
    end

    IDT -.->|替换| FRED["FRED delivery + ERETU/ERETS"]
    IRET -.->|替换| FRED
    SYS --> FRED
    IRQ --> FRED

一句话：快在「替代 IDT 查门 + 替代笨重 IRET（及连带 SWAPGS/IST/边角软件）」这类通用事件进/出；syscall 并入同一硬件投递，主要换一致性和完整性，延迟要和旧 SYSRET 路径分开评价。

六、三路总览

七、容易踩的坑

1. 「硬件中断 = 软件扫 IDT 表」 → CPU 按向量索引查一项门描述符¹。
2. 「syscall 完全靠 MSR，与中断无关」 → 传统 64 位对；int 0x80 仍走 IDT；FRED 下 syscall 是 FRED 事件⁴。
3. 「两种方式进内核后 pt_regs 构建相同」 → 结果都是 pt_regs *，过程不同（HW IRET vs 全软件 push vs FRED 帧）。
4. 「FRED 让 IDT、MSR、pt_regs 都消失」 / 「FRED 不用 pt_regs」 → 仅统一投递；pt_regs 仍在；启用后会 idt_invalidate()（§4.1）。
5. 「TSS.RSP0 / IST 也管 SYSCALL」 / 「RSP0 = 该进程内核栈」 → 否；传统 syscall 不用 RSP0/IST；Linux 上 RSP0 常是 entry 栈（§4.7）。
6. 「IST / #DF 不用 pt_regs」 → 仍建；IST 只换栈（§3、§4.7）。
7. 「FRED 打开后就不能发 syscall/int」 → 指令仍可用；出口改 ERETU，SYSRET/SYSEXIT 为 #UD（§4.2）。
8. 「FRED 下完全不用旧 MSR」 → LSTAR/FMASK 不参与跳转/旧掩码；STAR 仍用于 CS/SS；另有整套 FRED MSR（§4.3）。
9. 「FRED 统一了任务切换」 → 否；统一的是事件进核/返回，不是 schedule（§4.6）。
10. 「FRED 一定比旧路径更快」 → 相对 IDT+IRET 是设计目标；相对 SYSRET 须分开评价（§5.4）。
11. 「CONFIG_X86_FRED 和 fred= 都是编译选项」 → 前者编译期，后者引导参数（§4.1）。
12. 「生产环境已在用 FRED」 → 需 CPU 支持 + 配置；可用 fred=off 关闭⁵。

后续如果单独跟一遍 FRED 栈级别和 KVM 路径，再写一篇。

References

• 上一篇 Rust 生命周期标注在解决什么：返回值依赖、min 约束与 Java 为何不用
• 下一篇 CR3、HEAD 与 Catalog：分页、Git、Iceberg 共用的「可变指针 + 不可变树」