相信大家在看有关BPF的文章时,都有听过“字节码”一说,在讲字节码之前,我们先来了解一下,什么是机器码?机器码(machine code),也叫原生码(native code),就是CPU能够直接读取并运行的代码,执行速度最快的代码,用二进制编码表示,也叫做机器指令码。它和CPU体系架构强相关。
那么什么是字节码?字节码(byte code)是一种中间状态的二进制代码,是由源码编译过来的,可读性没有源码高,而且CPU也不能够直接读取字节码。字节码是一种中间码,它比机器码更抽象,需要直译器转译后才能成为机器码的中间代码。
说到字节码,就不得不提到JVM虚拟机,java源程序经过编译器编译后变成字节码,字节码由虚拟机解释执行,虚拟机将每一条要执行的字节码送给解释器,解释器将其翻译成特定机器上的机器码,然后在特定机器上运行。它的运行顺序是:
java源代码 -> 编译器 -> JVM可执行的字节码 -> JVM中的解释器 -> 机器可执行的二进制机器码 -> 程序运行
java采用字节码的好处是,在一定程度上解决了传统解释型语言执行效率低的问题,同时又保留了解释型语言可移植的特点。所以java程序运行时比较高效,而且由于字节码并不专对于一种特定的机器,因此java程序无需重新编译便可以在多种不同的计算机上运行。
说完java里面的字节码以及它的运行逻辑,也了解到它的可移植性和执行效率问题,我们很自然的想到,BPF字节码,也具有异曲同工之妙。如下图所示,我们一般将BPF程序编译后生成BPF字节码,然后将BPF字节码注入到内核中,当有事件触发时,就会执行相应的BPF程序。这里生成字节码的方式,我们需要用到一个编译器,比如当前主要是用C语言去编写BPF程序,通过LLVM/Clang编译生成BPF字节码,这是一种中间代码,将这段字节码加载到内核之后,Linux的验证程序确保它可以安全地运行,防止出现可能会使内核崩溃而危及系统的代码。Linux内核还为BPF指令集成了即时(JIT)编译器,JIT将直接将BPF字节码转换为机器码,从而避免了执行时间的开销。
我们看到,BPF字节码起到了非常关键的作用,虽然将用户BPF程序转成字节码是通过Clang编译器完成的,如你所愿,我们不用关心这个字节码或者说指令集长得怎么样?编译器替我们干了这个脏活累活。但是,为了能提高编写代码和执行代码的效率问题,为了让Linux内核校验出错时,能快速定位出报错根因,我们有必要了解一下BPF的字节码。
这里有很多概念,我们再来总结一下:
伪机器码:假的机器码,机器码都是能够在物理机上直接执行的,伪机器码不能够直接执行,需要在虚拟机上执行。BPF字节码就是伪机器码。
BPF指令集:BPF字节码,是一条条的BPF指令,BPF指令集就是伪机器码,是不能够在物理机上直接执行的,需要一个虚拟机才能够执行。我们都知道不同的处理器体系结构有自己的不同指令集,我们所说的BPF指令集可以理解为在BPF虚拟机上执行的指令集。
JIT:just in time 的缩写,我们将编译好的BPF指令集需要在虚拟机上执行,虚拟机需要一条一条的解析为本机机器码才能够执行,所以这个执行效率会很低,但是如果我们的处理器有了JIT就能够将我们BPF直接直接编译为能够在机器直接执行的机器码,这样大大提高了执行的速度。
在没有严格区分的情况下,我们说BPF字节码和BPF指令,是指同一个概念。
BPF指令集是一个通用的 RISC 指令集,指令集由指令操作码和寄存器组成。我们知道在1992年诞生了BPF技术,当时的寄存器和指令数目非常有限,到后来eBPF技术发展起来,寄存器和指令数目多了很多。为了区别,原来的BPF又称之为classic BPF(cBPF)。
我们先从功能上,对比一下cBPF和eBPF:
一、cBPF支持的功能比较单一,常用在网络的数据包过滤,比如大名鼎鼎的tcpdump。而eBPF除了能够支持网络的数据包的过滤外,也支持其他的事件类型,如XDP、Perf Event、kprobe、tracepoint等等。
二、eBPF引入Map机制。在cBPF我们通过接收队列将过滤后数据获取出来,但是在eBPF我们可以将数据放到Map空间中。Map空间是用户空间和内核空间共享的,所以一般是在内核中将数据存入到Map空间中,然后在用户空间取出数据。或者用户空间写入一些控制逻辑,内核空间根据它进行分支选择。
三、eBPF指令集变得更复杂了,以便支持更多功能。与此同时,有了专门的用于编译BPF字节码的编译器clang/llvm,这样我们就可以基于c语言等进行BPF程序的开发,而不是直接写BPF汇编。
四、还有在安全机制方面等等一些改变。
在讲BPF指令集前,我们先看一下,大家非常熟悉的tcpdump,这是一个通过输入表达式(其实是一些过滤规则)进行网络抓包的工具,然后通过libpcap把这个表达式转换成cBPF的字节码的。
这个字节码或者指令可以通过-d(-dd可以看到具体的指令格式)命令去查看,比如:
#tcpdump -d -i eth0 tcp and port 80
(000) ldh [12]
(001) jeq #0x86dd jt 2 jf 8
(002) ldb [20]
(003) jeq #0x6 jt 4 jf 19
(004) ldh [54]
(005) jeq #0x50 jt 18 jf 6
(006) ldh [56]
(007) jeq #0x50 jt 18 jf 19
(008) jeq #0x800 jt 9 jf 19
(009) ldb [23]
(010) jeq #0x6 jt 11 jf 19
(011) ldh [20]
(012) jset #0x1fff jt 19 jf 13
(013) ldxb 4*([14]&0xf)
(014) ldh [x + 14]
(015) jeq #0x50 jt 18 jf 16
(016) ldh [x + 16]
(017) jeq #0x50 jt 18 jf 19
(018) ret #262144
(019) ret #0
#tcpdump -dd -i eth0 tcp and port 80
{ 0x28, 0, 0, 0x0000000c },
{ 0x15, 0, 6, 0x000086dd },
{ 0x30, 0, 0, 0x00000014 },
{ 0x15, 0, 15, 0x00000006 },
{ 0x28, 0, 0, 0x00000036 },
{ 0x15, 12, 0, 0x00000050 },
{ 0x28, 0, 0, 0x00000038 },
{ 0x15, 10, 11, 0x00000050 },
{ 0x15, 0, 10, 0x00000800 },
{ 0x30, 0, 0, 0x00000017 },
{ 0x15, 0, 8, 0x00000006 },
{ 0x28, 0, 0, 0x00000014 },
{ 0x45, 6, 0, 0x00001fff },
{ 0xb1, 0, 0, 0x0000000e },
{ 0x48, 0, 0, 0x0000000e },
{ 0x15, 2, 0, 0x00000050 },
{ 0x48, 0, 0, 0x00000010 },
{ 0x15, 0, 1, 0x00000050 },
{ 0x6, 0, 0, 0x00040000 },
{ 0x6, 0, 0, 0x00000000 },
cBPF架构的基本元素如下,以下内容来源于linux 内核目录下的:
Documentation/networking/filter.rst
元素 | 描述 |
A | 32位累加器 |
X | 32位X寄存器 |
M[] | 16*32位的杂项寄存器,又称为临时寄存器, 可寻找范围:0~15 |
cBPF汇编的一条指令为64字节, 在头文件<usr/include/linux/filter.h>中有定义。如下所示。
16bit的code表示具体的操作类型,有加载/存储,跳转,运算等类型;
8 bit的jt 和 jf 是用于提供代码的跳转偏移量,jt为真跳转,jf为假跳转;
32bit的k为通用值,根据指令类型有不同含义。
struct sock_filter { /* Filter block */
__u16 code; /* Actual filter code */
__u8 jt; /* Jump true */
__u8 jf; /* Jump false */
__u32 k; /* Generic multiuse field */
};
对于网络报文的过滤,有一个例子是直接将struct sock_filter数组的指针通过setsockopt(2) 传递给内核:
/* From the example above: tcpdump -i em1 port 22 -dd */
struct sock_filter code[] = {
{ 0x28, 0, 0, 0x0000000c },
{ 0x15, 0, 8, 0x000086dd },
{ 0x30, 0, 0, 0x00000014 },
{ 0x15, 2, 0, 0x00000084 },
{ 0x15, 1, 0, 0x00000006 },
{ 0x15, 0, 17, 0x00000011 },
{ 0x28, 0, 0, 0x00000036 },
{ 0x15, 14, 0, 0x00000016 },
{ 0x28, 0, 0, 0x00000038 },
{ 0x15, 12, 13, 0x00000016 },
{ 0x15, 0, 12, 0x00000800 },
{ 0x30, 0, 0, 0x00000017 },
{ 0x15, 2, 0, 0x00000084 },
{ 0x15, 1, 0, 0x00000006 },
{ 0x15, 0, 8, 0x00000011 },
{ 0x28, 0, 0, 0x00000014 },
{ 0x45, 6, 0, 0x00001fff },
{ 0xb1, 0, 0, 0x0000000e },
{ 0x48, 0, 0, 0x0000000e },
{ 0x15, 2, 0, 0x00000016 },
{ 0x48, 0, 0, 0x00000010 },
{ 0x15, 0, 1, 0x00000016 },
{ 0x06, 0, 0, 0x0000ffff },
{ 0x06, 0, 0, 0x00000000 },
};
struct sock_fprog bpf = {
.len = ARRAY_SIZE(code),
.filter = code,
};
sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
if (sock < 0)
/* ... bail out ... */
ret = setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &bpf, sizeof(bpf));
if (ret < 0)
/* ... bail out ... */
/* ... */
close(sock);
由于性能有限, 因此后面cBPF由发展成为eBPF, 有新的指令和架构。原始的BPF指令会被自动翻译为新的eBPF指令,目前在Linux内核里,bpf_convert_filter()函数在做这个转换。
接下来我们重点来介绍eBPF的指令集。参考自:
Documentation/bpf/instruction-set.rst
Documentation/bpf/classic_vs_extended.rst
eBPF 由 11 个 64 位寄存器、一个程序计数器PC和一个 512 字节的大 BPF 堆栈空间组成。寄存器被命名为r0- r10。操作模式默认为 64 位。64位的寄存器也可作32 位子寄存器使用,它们只能通过特殊的 ALU(算术逻辑单元)操作访问,使用低32位,高32位使用零填充。
寄存器的使用约定如下:
寄存器 | 使用 |
r0 | 包含BPF程序返回值,返回值的语义由程序类型定义 |
r1-r5 | 保存从BPF程序到helper函数的参数,其中r1寄存器指向程序的上下文,例如网络程序的skb |
r6-r9 | 通用寄存器 |
r10 | 唯一只读寄存器,包含用于访问BPF堆栈空间的帧指针地址 |
在加载和存储指令中,寄存器 R6 是一个隐式输入,必须包含指向 sk_buff(ctx)的指针。寄存器 R0 是一个隐式输出,它包含从数据包中获取的数据。
struct bpf_insn 结构体用来表示eBPF具体的指令格式:
struct bpf_insn {
__u8 code; /* opcode */
__u8 dst_reg:4; /* dest register */
__u8 src_reg:4; /* source register */
__s16 off; /* signed offset */
__s32 imm; /* signed immediate constant */
};
其中的code字段,如下:
+----------------+--------+--------------------+
| 4 bits | 1 bit | 3 bits |
| operation code | source | instruction lass |
+----------------+--------+--------------------+
(MSB) (LSB)
opcode字段的低3位,决定指令类型。指令类型包含:加载与存储指令、运算指令、跳转指令。
cBPF | eBPF | value |
BPF_LD | BPF_LD | 0x00 |
BPF_LDX | BPF_LDX | 0x01 |
BPF_ST | BPF_ST | 0x02 |
BPF_STX | BPF_STX | 0x03 |
BPF_ALU | BPF_ALU | 0x04 |
BPF_JMP | BPF_JMP | 0x05 |
BPF_RET | BPF_JMP32 | 0x06 |
BPF_MISC | BPF_ALU64 | 0x07 |
eBPF把BPF_RET和BPF_MISC指令去掉了,换成了BPF_JMP32和BPF_ALU64,提供更大范围的跳转和64位场景下的运算操作。
BPF_LD 和 BPF_LDX: 两个类都用于加载操作。BPF_LD用于加载双字。后者是从 cBPF 继承而来的,主要是为了保持 cBPF 到 eBPF 的转换效率,因为它们优化了JIT 代码。
BPF_ST 和 BPF_STX: 两个类都用于存储操作,用于将数据从寄存器到存储器中。
BPF_ALU 和 BPF_ALU64: 分别是32位和64位下的ALU操作。
BPF_JMP 和 BPF_JMP32:跳转指令。JMP32的跳转范围是32位大小(一个字)
当 BPF_CLASS(code) == BPF_ALU 或 BPF_JMP 时,code字段可分为三部分,如下所示:
+----------------+--------+--------------------+
| 4 bits | 1 bit | 3 bits |
| operation code | source | instruction class |
+----------------+--------+--------------------+
(MSB) (LSB)
其中的第四位source,可以为0或者1,在linux中,使用如下宏定义:
BPF_K 0x00
BPF_X 0x08
在cBPF中,表示:
BPF_SRC(code) == BPF_X - use register X as source operand
BPF_SRC(code) == BPF_K - use 32-bit immediate as source operand
在 eBPF 中,这意味着:
BPF_SRC(code) == BPF_X - use 'src_reg' register as source operand
BPF_SRC(code) == BPF_K - use 32-bit immediate as source operand
也就是说,操作数的选择上,BPF_K代表使用立即数,BPF_X代表使用源寄存器的内容。
如果 BPF_CLASS(code) 等于 BPF_ALU 或 BPF_ALU64,则 BPF_OP(code) 是以下之一:
BPF_ADD 0x00
BPF_SUB 0x10
BPF_MUL 0x20
BPF_DIV 0x30
BPF_OR 0x40
BPF_AND 0x50
BPF_LSH 0x60
BPF_RSH 0x70
BPF_NEG 0x80
BPF_MOD 0x90
BPF_XOR 0xa0
BPF_MOV 0xb0 /* eBPF only: mov reg to reg */
BPF_ARSH 0xc0 /* eBPF only: sign extending shift right */
BPF_END 0xd0 /* eBPF only: endianness conversion */
如果 BPF_CLASS(code) 等于 BPF_JMP 或 BPF_JMP32,则 BPF_OP(code) 是以下之一:
BPF_JA 0x00 /* BPF_JMP only */
BPF_JEQ 0x10
BPF_JGT 0x20
BPF_JGE 0x30
BPF_JSET 0x40
BPF_JNE 0x50 /* eBPF only: jump != */
BPF_JSGT 0x60 /* eBPF only: signed '>' */
BPF_JSGE 0x70 /* eBPF only: signed '>=' */
BPF_CALL 0x80 /* eBPF BPF_JMP only: function call */
BPF_EXIT 0x90 /* eBPF BPF_JMP only: function return */
BPF_JLT 0xa0 /* eBPF only: unsigned '<' */
BPF_JLE 0xb0 /* eBPF only: unsigned '<=' */
BPF_JSLT 0xc0 /* eBPF only: signed '<' */
BPF_JSLE 0xd0 /* eBPF only: signed '<=' */
当 BPF_CLASS(code) 等于 BPF_LD 或 BPF_ST 时,op字段可分为三部分,如下所示:
+--------+--------+-------------------+
| 3 bits | 2 bits | 3 bits |
| mode | size | instruction class |
+--------+--------+-------------------+
(MSB) (LSB)
其中的size定义如下:
BPF_W 0x00 /* word=4 byte */
BPF_H 0x08 /* half word */
BPF_B 0x10 /* byte */
BPF_DW 0x18 /* eBPF only, double word */
B - 1 byte
H - 2 byte
W - 4 byte
DW - 8 byte (eBPF only)
mode定义如下:
BPF_IMM 0x00 /* used for 32-bit mov in classic BPF and 64-bit in eBPF */
BPF_ABS 0x20
BPF_IND 0x40
BPF_MEM 0x60
BPF_LEN 0x80 /* classic BPF only, reserved in eBPF */
BPF_MSH 0xa0 /* classic BPF only, reserved in eBPF */
BPF_ATOMIC 0xc0 /* eBPF only, atomic operations */
前面我们介绍了eBPF和cBPF的基础指令码,接下来一起看看eBPF的指令构成是什么样子的,这有助于我们去分析verifier出错时的一些根因定位。以x86_64为例,先介绍一下eBPF使用到的几个寄存器和x86_64的映射关系:
R0 - rax
R1 - rdi
R2 - rsi
R3 - rdx
R4 - rcx
R5 - r8
R6 - rbx
R7 - r13
R8 - r14
R9 - r15
R10 - rbp
rdi、rsi、rdx、rcx是传递的参数和顺序。
下面是一段eBPF的伪代码:
Then the following eBPF pseudo-program::
bpf_mov R6, R1 /* save ctx */
bpf_mov R2, 2
bpf_mov R3, 3
bpf_mov R4, 4
bpf_mov R5, 5
bpf_call foo
bpf_mov R7, R0 /* save foo() return value */
bpf_mov R1, R6 /* restore ctx for next call */
bpf_mov R2, 6
bpf_mov R3, 7
bpf_mov R4, 8
bpf_mov R5, 9
bpf_call bar
bpf_add R0, R7
bpf_exit
上面伪代码包括寄存器赋值,运算和跳转,以及返回。
如果机器上开启了相关架构的jit功能,会转成对应架构的汇编指令:
push %rbp
mov %rsp,%rbp
sub $0x228,%rsp
mov %rbx,-0x228(%rbp)
mov %r13,-0x220(%rbp)
mov %rdi,%rbx
mov $0x2,%esi
mov $0x3,%edx
mov $0x4,%ecx
mov $0x5,%r8d
callq foo
mov %rax,%r13
mov %rbx,%rdi
mov $0x6,%esi
mov $0x7,%edx
mov $0x8,%ecx
mov $0x9,%r8d
callq bar
add %r13,%rax
mov -0x228(%rbp),%rbx
mov -0x220(%rbp),%r13
leaveq
retq
大概对应到的c程序:
u64 bpf_filter(u64 ctx)
{
return foo(ctx, 2, 3, 4, 5) + bar(ctx, 6, 7, 8, 9);
}
为了加深对前面所介绍的基础指令的认识,我们分析一下这段代码:
sample/bpf/sock_example.c
本节来自于网络。
抽取关键的这个信息:
struct bpf_insn prog[] = {
BPF_MOV64_REG(BPF_REG_6, BPF_REG_1), /* R6 = R1*/ /* R6指向数据包地址 */
BPF_LD_ABS(BPF_B, ETH_HLEN + offsetof(struct iphdr, protocol) /* R0 = ip->proto */), /*R6作为隐式输入,R0作为隐式输出。结果R0报错IP协议值*/
BPF_STX_MEM(BPF_W, BPF_REG_10, BPF_REG_0, -4), /* *(u32 *)(fp - 4) = r0 */ /* 将协议值保存在栈中*/
BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), /*R10只读寄存器,指向栈帧。复制一份到R2中*/
BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4), /* r2 = fp - 4 */ /* 内核bpf_map_lookup_elem函数的第二个参数key的内存地址放在R2中 */
BPF_LD_MAP_FD(BPF_REG_1, map_fd), /* 内核bpf_map_lookup_elem函数的第一个参数map_fd放在R1中 */
BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_map_lookup_elem), /* 函数的返回值为value所在内存的地址,放在R0寄存器中*/
BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 2), /* 如果返回的内存地址为0,则向下跳两个指令 */
BPF_MOV64_IMM(BPF_REG_1, 1), /* r1 = 1 */
BPF_RAW_INSN(BPF_STX | BPF_XADD | BPF_DW, BPF_REG_0, BPF_REG_1, 0, 0), /* xadd r0 += r1 */ /* value的值加一;结果R0存储1,R1存储value地址 */
BPF_MOV64_IMM(BPF_REG_0, 0), /* r0 = 0 */
BPF_EXIT_INSN(), /* R0作为返回值,返回零 */
};
下面我们对上面代码逐行指令进行梳理:
第一条指令
/* Short form of mov, dst_reg = src_reg */
#define BPF_MOV64_REG(DST, SRC) \
((struct bpf_insn) { \
.code = BPF_ALU64 | BPF_MOV | BPF_X, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = 0, \
.imm = 0 })
BPF_MOV64_REG这条指令是将源寄存器R1的值移动到R6寄存器中。其中,R1指向数据包的起始地址,一般是skb指针。
第二条指令
/* Direct packet access, R0 = *(uint *) (skb->data + imm32) */
#define BPF_LD_ABS(SIZE, IMM) \
((struct bpf_insn) { \
.code = BPF_LD | BPF_SIZE(SIZE) | BPF_ABS, \
.dst_reg = 0, \
.src_reg = 0, \
.off = 0, \
.imm = IMM })
在加载和存储指令中,寄存器 R6 是一个隐式输入,寄存器 R0 是一个隐式输出。
根据偏移量,读取IP协议类型,例如,TCP 的协议号为 6,UDP 的协议号为 17,ICMP 的协议号为 1。其中,协议字段占8位。
所以,BPF_LD_ABS这条指令表示,将 IP 协议值放入 R0 寄存器。
第三条指令
/* Memory store, *(uint *) (dst_reg + off16) = src_reg */
#define BPF_STX_MEM(SIZE, DST, SRC, OFF) \
((struct bpf_insn) { \
.code = BPF_STX | BPF_SIZE(SIZE) | BPF_MEM, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = OFF, \
.imm = 0 })
R10是唯一的只读寄存器,包含用于访问 BPF 堆栈空间的帧指针地址。(关于栈帧结构可以参考:gdb调试之栈帧信息)
这条指令意思是将R0寄存器中的内容(上一步保存了协议类型),保存到栈中。需要注意的是,这里是 BPF_W,只保存了 R0寄存器中的第32位。
第四条指令
BPF_MOV64_REG(BPF_REG_2, BPF_REG_10)
因为栈向下生长了。所以这里使用了 R2寄存器指向栈顶。
BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -4)
/* ALU ops on immediates, bpf_add|sub|...: dst_reg += imm32 */
#define BPF_ALU64_IMM(OP, DST, IMM) \
((struct bpf_insn) { \
.code = BPF_ALU64 | BPF_OP(OP) | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = 0, \
.imm = IMM })
上面的指令展开,便是一个64位的二进制数,r2-4的结果放在r2里。展开可以在 samples/bpf/bpf_insn.h 和 include/uapi/linux/bpf.h 中查看。
第五条指令
/* BPF_LD_IMM64 macro encodes single 'load 64-bit immediate' insn */
#define BPF_LD_IMM64(DST, IMM) \
BPF_LD_IMM64_RAW(DST, 0, IMM)
#define BPF_LD_IMM64_RAW(DST, SRC, IMM) \
((struct bpf_insn) { \
.code = BPF_LD | BPF_DW | BPF_IMM,\
.dst_reg = DST, \
.src_reg = SRC, \
.off = 0, \
.imm = (__u32) (IMM) }), \
((struct bpf_insn) { \
.code = 0, \
.dst_reg = 0, \
.src_reg = 0, \
.off = 0, \
.imm = ((__u64) (IMM)) >> 32 })
#ifndef BPF_PSEUDO_MAP_FD
# define BPF_PSEUDO_MAP_FD 1
#endif
/* pseudo BPF_LD_IMM64 insn used to refer to process-local map_fd */
#define BPF_LD_MAP_FD(DST, MAP_FD) \
BPF_LD_IMM64_RAW(DST, BPF_PSEUDO_MAP_FD, MAP_FD)
可以看到,这条指令是将 map_fd 的值,保存到R1寄存器中。这时候,我们可能会好奇,这中间有 src_reg 什么事情?
上面我们可以看到,如果只是单纯将一个立即数保存到寄存器中,则 src_reg=0;如果这个立即数表示是一个 map_fd,则则 src_reg=1;
这样我们便可以区分指令中的立即数是否表示一个 map_fd。后面 replace_map_fd_with_map_ptr 函数会用到这个性质。
第六条指令
/* Raw code statement block */
#define BPF_RAW_INSN(CODE, DST, SRC, OFF, IMM) \
((struct bpf_insn) { \
.code = CODE, \
.dst_reg = DST, \
.src_reg = SRC, \
.off = OFF, \
.imm = IMM })
其中BPF_FUNC_map_lookup_elem的宏展开为1。至于跳转到1的位置,在verifier后是bpf_map_lookup_elem这个函数,则是后续的问题了。可以参考:fixup_bpf_calls
这里,可以从宏的名称看出是是跳转到bpf_map_lookup_elem函数位置。
第七条指令
/* Conditional jumps against immediates, if (dst_reg 'op' imm32) goto pc + off16 */
#define BPF_JMP_IMM(OP, DST, IMM, OFF) \
((struct bpf_insn) { \
.code = BPF_JMP | BPF_OP(OP) | BPF_K, \
.dst_reg = DST, \
.src_reg = 0, \
.off = OFF, \
.imm = IMM })
这条指令表示,R0寄存器 等于0,则向下跳过两个指令。
R0寄存器 这里存储的是协议号,根据 IP 协议号列表可知,但 IP 数据包中的协议为 “IPv6逐跳选项”,则向下跳过两个指令。
第八条指令
BPF_RAW_INSN(BPF_STX | BPF_XADD | BPF_DW, BPF_REG_0, BPF_REG_1, 0, 0)
xadd - 交换相加。
第九条指令
BPF_MOV64_IMM(BPF_REG_0, 0), /* r0 = 0 */
R0是包含 BPF 程序退出值的寄存器,设置返回值 R0=0。
第十条指令
/* Program exit */
#define BPF_EXIT_INSN() \
((struct bpf_insn) { \
.code = BPF_JMP | BPF_EXIT, \
.dst_reg = 0, \
.src_reg = 0, \
.off = 0, \
.imm = 0 })
程序退出指令,使用BPF_EXIT
前面我们介绍了eBPF的字节码和指令架构的定义,也拿了一个具体的例子进行了分析,通过eBPF的字节码(指令集)有助于我们理解eBPF程序。在进行eBPF程序开发时,会遇到很多verifier的报错,经过学习本文后,通过读报错信息就可以大概知道什么地方的问题了。
大家可以参考《收藏:eBPF verifier常见错误整理》
https://mp.weixin.qq.com/s/1za4Xk_dgafd_kMOkhLw1w