elem
品牌方跟主播的最后一天活动??
很美哦ELEMIS pop-up
#英国 #移民 #海外生活 #美妆 #护肤
elem是什么意思
1、什么是字节码
相信大家在看有关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指令，是指同一个概念。
2、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汇编。
四、还有在安全机制方面等等一些改变。
2.1 tcpdump和cBPF指令码在讲BPF指令集前，我们先看一下，大家非常熟悉的tcpdump，这是一个通过输入表达式（其实是一些过滤规则）进行网络抓包的工具，然后通过libpcap把这个表达式转换成cBPF的字节码的。
这个字节码或者指令可以通过-d(-dd可以看到具体的指令格式)命令去查看，比如：
#tcpdump -d -i eth0 tcp and port 80(000) ldh [12](001) jeq #0x86dd jt 2jf 8(002) ldb [20](003) jeq #0x6 jt 4jf 19(004) ldh [54](005) jeq #0x50 jt 18jf 6(006) ldh [56](007) jeq #0x50 jt 18jf 19(008) jeq #0x800 jt 9jf 19(009) ldb [23](010) jeq #0x6 jt 11jf 19(011) ldh [20](012) jset #0x1fff jt 19jf 13(013) ldxb 4*([14]&0xf)(014) ldh [x + 14](015) jeq #0x50 jt 18jf 16(016) ldh [x + 16](017) jeq #0x50 jt 18jf 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 */__u16code; /* Actual filter code */__u8jt;/* Jump true */__u8jf;/* Jump false */__u32k; /* 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()函数在做这个转换。
2.2 eBPF指令集接下来我们重点来介绍eBPF的指令集。参考自：
Documentation/bpf/instruction-set.rst
Documentation/bpf/classic_vs_extended.rst
eBPF的寄存器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 是一个隐式输出，它包含从数据包中获取的数据。
eBPF的指令格式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 0x00BPF_X 0x08在cBPF中，表示：
BPF_SRC(code) == BPF_X - use register X as source operandBPF_SRC(code) == BPF_K - use 32-bit immediate as source operand
在 eBPF 中，这意味着：
BPF_SRC(code) == BPF_X - use 'src_reg' register as source operandBPF_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 0x20BPF_IND 0x40BPF_MEM 0x60BPF_LEN 0x80 /* classic BPF only, reserved in eBPF */BPF_MSH 0xa0 /* classic BPF only, reserved in eBPF */BPF_ATOMIC 0xc0 /* eBPF only, atomic operations */
3、eBPF汇编前面我们介绍了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 - rbprdi、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
4、总结前面我们介绍了eBPF的字节码和指令架构的定义，也拿了一个具体的例子进行了分析，通过eBPF的字节码（指令集）有助于我们理解eBPF程序。在进行eBPF程序开发时，会遇到很多verifier的报错，经过学习本文后，通过读报错信息就可以大概知道什么地方的问题了。
大家可以参考《收藏：eBPF verifier常见错误整理》
https://mp.weixin.qq.com/s/1za4Xk_dgafd_kMOkhLw1w
作者:毛文安
来源:微信公众号:酷玩BPF
出处:https://mp.weixin.qq.com/s/RB-q8IAz3L-OSmkygMTBEg
