• 保存需要保留的寄存器（callee-saved registers）

• 在栈上分配栈帧空间（sub sp, sp, #xxx）

• 设置栈指针、建立栈帧（可选，如 fp = sp）

这一段开头固定模板代码，就叫 prologue。

Epilogue（栈帧尾声）：函数执行完要返回前，必须：

• 恢复栈指针（add sp, sp, #0x30）

• 恢复之前保存的寄存器

• 执行 ret 跳回调用者

这一段结尾固定模板代码，就叫 epilogue。

2.1 寄存器映射规则

eBPF虚拟寄存器与ARM64物理寄存器严格映射，保证调用 convention 兼容：

注：ARM64返回值寄存器x5在函数最后会被移至x0，符合标准ABI。

三、核心模块划分

ARM64 eBPF JIT编译器代码位于`arch/arm64/net/bpf_jit_comp.c`，核心模块如下：

1 上下文管理模块jit_ctx

功能：维护编译过程全局状态，贯穿整个编译流程。

核心数据结构：

struct jit_ctx {struct bpf_prog *prog;    // 输入eBPF程序    u32 *image;                // 输出机器码缓冲区    int idx;                   // 当前指令索引（4字节为单位）    int *offset;               // eBPF指令对应机器码偏移表    int epilogue_offset;      // epilogue代码起始偏移    bool extra_pass;           // 是否为第一趟预编译    // 其他辅助字段...};

2 入口编译模块bpf_int_jit_compile

功能：JIT编译总入口，协调两趟编译、内存分配、缓存刷新、安全加固。

3 栈帧生成模块build_prologue/build_epilogue

功能：生成函数入口/出口代码，处理栈帧创建、寄存器保存/恢复、栈释放。

4 指令翻译模块build_body/build_insn

功能：遍历eBPF指令，逐条翻译为ARM64机器码，是核心翻译逻辑。

5 指令发射辅助模块emit_*系列函数

功能：封装ARM64指令编码细节，供`build_insn`调用生成各类指令（算术、跳转、内存访问、函数调用等）。

6 内存与缓存管理模块

功能：分配ROX属性内存、刷新指令缓存、锁定内存只读。

四、模块调用框图

五、核心函数详解

5.1 编译入口bpf_int_jit_compile

功能：协调整个JIT编译流程，是内核`bpf_prog_select_runtime`的回调函数。

源码流程：

void bpf_int_jit_compile(struct bpf_prog *prog){struct bpf_binary_header *header;struct jit_ctx ctx;    int image_size;    u8 *image_ptr;    // 1. 检查JIT是否启用、程序是否合法    if (!bpf_jit_enable || !prog || !prog->len)        return;    // 2. 初始化编译上下文    memset(&ctx, 0, sizeof(ctx));    ctx.prog = prog;    // 分配指令偏移表：记录每个eBPF指令对应机器码的偏移    ctx.offset = kcalloc(prog->len, sizeof(int), GFP_KERNEL);    if (!ctx.offset)        return;    // 3. 第一趟：预编译（Fake Pass），仅计算长度和偏移    ctx.extra_pass = true; // 标记为预编译，不实际生成代码    if (build_prologue(&ctx, prog->was_classic)) // 生成栈帧入口（算长度）        goto out;    if (build_body(&ctx)) // 遍历所有eBPF指令，更新ctx->idx/offset        goto out;    ctx.epilogue_offset = ctx.idx; // 记录epilogue起始偏移    build_epilogue(&ctx); // 生成栈帧出口（算长度）    // 4. 分配ROX内存：可执行、只读、内核空间（核心内存分配步骤）    image_size = sizeof(u32) * ctx.idx; // 机器码总字节数（4字节/指令）    header = bpf_jit_binary_alloc(image_size, &image_ptr, sizeof(u32), jit_fill_hole);    if (!header)        goto out;    ctx.image = (u32 *)image_ptr; // 绑定上下文到新内存    // 5. 第二趟：正式编译（Real Pass），生成实际机器码    ctx.extra_pass = false;    ctx.idx = 0; // 重置索引，从头生成    if (build_prologue(&ctx, prog->was_classic))        goto out_free;    if (build_body(&ctx))        goto out_free;    build_epilogue(&ctx);    // 6. 缓存同步：确保CPU指令缓存读取新生成的代码    flush_icache_range((unsigned long)header, (unsigned long)ctx.image + ctx.idx * sizeof(u32));    // 7. 安全加固：将机器码内存设为只读，防止篡改（关键安全步骤）    bpf_jit_binary_lock_ro(header);    // 8. 关联JIT代码到eBPF程序，标记编译完成（为内核调用做准备）    prog->bpf_func = (void (*)(void))image_ptr;    prog->jited = 1;    prog->jited_len = image_size;out_free:    if (!prog->jited)        bpf_jit_binary_free(header);out:    kfree(ctx.offset);}

5.2 栈帧入口生成build_prologue

功能：生成函数入口代码，保存返回地址、栈帧指针、被调用者保存寄存器，创建栈帧。

核心流程：

static int build_prologue(struct jit_ctx *ctx, bool was_classic){    // 1. 保存栈帧指针(x29)和返回地址(x30)到栈    emit_stp(ctx, x29, x30, sp, -16, true); // 栈向下生长，分配16字节    emit_mov(ctx, x29, sp); // 设置新栈帧指针    // 2. 保存被调用者保存寄存器(x19-x22，对应eBPF r6-r9)    emit_stp(ctx, x19, x20, sp, -16, true);    emit_stp(ctx, x21, x22, sp, -16, true);    // 3. 设置eBPF帧指针r10(x23)，指向栈帧底部    emit_mov(ctx, x23, sp);    // 4. 经典BPF兼容处理（略）    return 0;}

5.3 指令体翻译主循环build_body

功能：遍历所有eBPF指令，调用`build_insn`逐条翻译，维护指令偏移表。

核心流程：

static int build_body(struct jit_ctx *ctx){    conststruct bpf_insn *insn = ctx->prog->insns;    int i;    // 遍历每一条eBPF指令    for (i = 0; i < ctx->prog->len; i++, insn++) {        // 记录当前eBPF指令对应机器码的起始偏移（字节为单位）        ctx->offset[i] = ctx->idx * sizeof(u32);        // 逐条翻译eBPF指令为ARM64机器码        if (build_insn(ctx, insn))            return -EINVAL;    }    return 0;}

5.4 单指令翻译核心build_insn

功能：根据eBPF指令类型（算术、跳转、内存访问、函数调用等），调用对应`emit_*`函数生成ARM64指令。

核心逻辑（switch-case分支）：

static int build_insn(struct jit_ctx *ctx, const struct bpf_insn *insn){    u8 code = insn->code;    u8 dst = insn->dst_reg;    u8 src = insn->src_reg;    s32 imm = insn->imm;    switch (BPF_CLASS(code)) {        case BPF_ALU64: // 64位算术指令            switch (code) {                case BPF_ALU64 | BPF_MOV | BPF_K: // 立即数赋值 rdst = imm                    emit_mov_imm(ctx, dst, imm);                    break;                case BPF_ALU64 | BPF_ADD | BPF_X: // 寄存器加法 rdst += rsrc                    emit_alu_reg(ctx, ADD, dst, src);                    break;                // 其他算术指令（SUB、MUL、DIV等，略）            }            break;        case BPF_JMP: // 跳转指令            switch (code) {                case BPF_JMP | BPF_JA: // 无条件跳转                    emit_jmp(ctx, imm);                    break;                case BPF_JMP | BPF_JEQ | BPF_X: // 条件跳转 rdst == rsrc                    emit_jmp_cond_reg(ctx, EQ, dst, src, imm);                    break;                // 其他条件跳转（JNE、JGT等，略）            }            break;        case BPF_LD: // 加载指令（内存→寄存器）            emit_ld(ctx, code, dst, src, imm);            break;        case BPF_ST: // 存储指令（寄存器→内存）            emit_st(ctx, code, dst, src, imm);            break;        case BPF_JMP | BPF_CALL: // 调用内核辅助函数            emit_call(ctx, imm);            break;        default:            return -EINVAL; // 不支持的指令    }    return 0;}

5.5 栈帧出口生成build_epilogue

功能：生成函数返回代码，恢复被调用者保存寄存器、栈帧指针、返回地址，跳转回调用者。

核心流程：

static void build_epilogue(struct jit_ctx *ctx){    // 1. 恢复被调用者保存寄存器(x21-x22, x19-x20)    emit_ldp(ctx, x21, x22, sp, 16);    emit_ldp(ctx, x19, x20, sp, 16);    // 2. 恢复栈帧指针(x29)和返回地址(x30)，释放栈帧    emit_ldp(ctx, x29, x30, sp, 16);    // 3. 将eBPF返回值r0(x5)移至ARM64标准返回寄存器x0    emit_mov(ctx, x0, x5);    // 4. 返回调用者（ret = br x30）    emit_ret(ctx);}

5.6 指令发射辅助emit_*系列函数

功能：封装ARM64指令编码细节，屏蔽硬件指令格式差异，供`build_insn`调用。

典型函数示例：

• • emit_mov_imm：生成立即数赋值指令（处理ARM64有限立即数范围，拆分大立即数）。
• • emit_alu_reg：生成寄存器算术指令（ADD/SUB/MUL等）。
• • emit_jmp：生成无条件跳转指令。
• • emit_call：生成内核辅助函数调用指令（加载函数地址到寄存器，BLR跳转）。
• • emit_stp/emit_ldp：生成栈保存/恢复指令（成对加载/存储，优化栈操作）。

六、关键技术细节

6.1 大立即数处理

ARM64指令的立即数范围有限（MOV指令仅支持16位立即数），eBPF中32/64位大立即数需拆分：

• • 低16位：MOVZ加载
• • 高16/32位：MOVK更新高位
• • 合并为完整64位立即数，存入目标寄存器。

6.2 辅助函数调用

eBPF的BPF_CALL指令用于调用内核预定义辅助函数（如bpf_map_lookup_elem），JIT处理流程：

1. 1. 将辅助函数索引（imm）转换为内核虚拟地址。
2. 2. 用MOV指令加载地址到临时寄存器。
3. 3. 用BLR指令跳转至该地址，符合ARM64调用约定。

6.3 安全与性能优化

• • ROX内存：JIT代码分配在set_memory_rox保护的内存，防止代码注入攻击。
• • 指令缓存刷新：flush_icache_range确保CPU执行最新生成的机器码，避免缓存不一致。
• • 寄存器直接映射：eBPF寄存器与ARM64寄存器一对一映射，无额外数据移动开销，提升性能。

七、JIT编译结果的ROX内存

eBPF JIT编译生成的ARM64机器码，存放在ROX内存中。ROX（Read-Only eXecutable，只读可执行）内存是Linux内核为动态生成可执行代码（如eBPF JIT、内核模块加载）专门设计的内存类型，核心定位是“可执行但不可篡改”，兼顾执行效率与安全防护，是eBPF JIT代码的核心存储载体。

7.1 ROX内存属性

ROX内存的属性由内核页表（Page Table）严格控制，依托MMU（内存管理单元）实现硬件级别的权限管控，核心属性可概括为“三特性一约束”：

1. 1. 只读性（Read-Only）：内存页被标记为只读，无论是内核态还是用户态，均无法通过常规指令修改内存中的内容（如JIT生成的机器码）。若尝试写入，MMU会触发页错误（Page Fault），内核会终止当前操作，从硬件层面防止恶意代码篡改可执行指令，避免代码注入攻击。
2. 2. 可执行性（eXecutable）：内存页被标记为可执行，CPU的程序计数器（PC寄存器）可指向该内存区域，正常取指、译码、执行指令，这是JIT代码能够被内核直接调用执行的核心前提。
3. 3. 内核空间归属：eBPF JIT的ROX内存属于内核虚拟地址空间（Kernel Virtual Address Space），而非用户态地址空间。其虚拟地址范围通常在VMALLOC_START到VMALLOC_END之间（ARM64架构下，该范围为0xffff000000000000至0xffff7fffffffffff），用户态程序无法直接访问，只能通过内核提供的eBPF接口间接触发执行，确保内核空间的隔离性。
4. 4. 动态可回收：与内核.text段（编译期固定、运行期不可回收）不同，ROX内存是运行期动态分配的，当eBPF程序被销毁（如用户态关闭eBPF句柄）时，内核会通过对应接口释放该内存，避免内存泄漏，适配eBPF程序“动态提交、动态销毁”的特性。

7.2 ROX内存的分配过程

负责内存分配的核心函数是bpf_jit_binary_alloc。其核心流程分为“分配-权限设置-使用-回收”四步，全程由内核严格管控：

1. 1. 内存分配：由bpf_jit_binary_alloc函数负责，底层调用内核vmalloc系列函数（vmalloc_node）分配连续的虚拟内存页（物理内存可不连续，由内核通过页表映射关联），分配的内存初始权限为“可执行、可写”（便于后续写入JIT机器码）。
2. 2. 权限切换：JIT机器码写入完成后，通过bpf_jit_binary_lock_ro函数将内存权限切换为“只读可执行”（ROX），核心是调用set_memory_rox函数修改内存页表的权限位（ARM64架构下，页表项的AP[2:1]位设置为01，实现只读；UXN位设置为0，实现可执行）。
3. 3. 使用期间：ROX内存仅用于存储JIT生成的机器码，内核通过函数指针指向该内存区域的起始地址，调用时触发CPU执行；期间任何写入操作都会被MMU拦截，确保代码完整性。
4. 4. 内存回收：当eBPF程序被销毁时，内核调用bpf_jit_binary_free函数，底层调用vfree函数释放虚拟内存，同时清理对应的页表映射，回收物理内存页，完成整个生命周期闭环。
5. 5. 补充：ARM64架构下，由于缓存与内存的一致性问题，动态生成的机器码写入内存后，必须刷新指令缓存，否则CPU可能执行缓存中的旧数据（垃圾数据）。

7.3 调用eBPF代码的过程

内核调用JIT编译后的eBPF代码，核心流程如下：

1. 1. 地址关联：JIT编译完成后，将动态分配的ROX内存起始地址（image_ptr）赋值给prog->bpf_func，即把JIT代码的入口地址，绑定到eBPF程序结构体的函数指针上——此时prog->bpf_func就相当于一个普通的内核函数指针，指向可执行的JIT代码入口。
2. 2. 权限校验：内核在调用prog->bpf_func前，会通过eBPF验证器（verifier）再次校验JIT代码的合法性（确保无非法内存访问、无越界操作），同时MMU会检查image_ptr对应的内存权限（必须是可执行），双重保障安全。
3. 3. 调用执行：内核通过函数指针调用的方式（如prog->bpf_func(args)），将CPU的PC寄存器指向image_ptr（JIT代码入口），CPU开始执行JIT生成的ARM64机器码——执行流程与调用普通内核函数完全一致，遵循ARM64调用约定（参数通过x0-x4传递，返回值通过x0返回）。
4. 4. 执行完成：JIT代码执行完毕后，通过build_epilogue生成的返回指令（br x30），跳转回内核调用者，完成一次eBPF程序执行。

补充说明：JIT代码的内存地址属于内核空间（虚拟地址），用户态无法直接访问，只能通过内核提供的eBPF接口（如bpf系统调用）间接触发执行，确保内核空间的隔离性与安全性。同时，内核会通过虚拟内存管理机制，将JIT内存的虚拟地址映射到物理内存页，MMU负责实时地址转换，保障代码执行的高效性，这一过程与内核执行静态.text段代码的地址转换逻辑一致。

八、总结

Linux内核ARM64 eBPF JIT编译器通过两趟编译、寄存器直接映射、栈帧精细管理，将eBPF字节码高效转换为ARM64原生机器指令。核心流程由bpf_int_jit_compile协调，经预编译计算布局、正式编译生成代码、缓存同步与安全加固，最终输出可直接执行的内核代码。