跳转到内容

std.os.linux.bpf

标准库Zig 0.17.0官方原文
源码std/os/linux/bpf.zig

第 1 行

std.os.linux.bpf.ABS

常量

第 35 行

std.os.linux.bpf.ADD

常量

第 42 行

std.os.linux.bpf.ALU

常量

第 20 行

std.os.linux.bpf.ALU64

常量

第 78 行

双字宽度的 alu 模式

std.os.linux.bpf.AND

常量

第 47 行

std.os.linux.bpf.ANY

常量

第 198 行

BPF_MAP_UPDATE_ELEM 命令的标志:创建新元素或更新现有元素。

std.os.linux.bpf.ARSH

常量

第 89 行

进行符号扩展的算术右移 */

std.os.linux.bpf.AttachType

容器

第 1235 行

字段

cgroup_inet_ingress
cgroup_inet_egress
cgroup_inet_sock_create
cgroup_sock_ops
sk_skb_stream_parser
sk_skb_stream_verdict
cgroup_device
sk_msg_verdict
cgroup_inet4_bind
cgroup_inet6_bind
cgroup_inet4_connect
cgroup_inet6_connect
cgroup_inet4_post_bind
cgroup_inet6_post_bind
cgroup_udp4_sendmsg
cgroup_udp6_sendmsg
lirc_mode2
flow_dissector
cgroup_sysctl
cgroup_udp4_recvmsg
cgroup_udp6_recvmsg
cgroup_getsockopt
cgroup_setsockopt
trace_raw_tp
trace_fentry
trace_fexit
modify_return
lsm_mac
trace_iter
cgroup_inet4_getpeername
cgroup_inet6_getpeername
cgroup_inet4_getsockname
cgroup_inet6_getsockname
xdp_devmap
cgroup_inet_sock_release
xdp_cpumap
sk_lookup
xdp
sk_skb_verdict
sk_reuseport_select
sk_reuseport_select_or_migrate
perf_event
trace_kprobe_multi
lsm_cgroup
struct_ops
netfilter
tcx_ingress
tcx_egress
trace_uprobe_multi
cgroup_unix_connect
cgroup_unix_sendmsg
cgroup_unix_recvmsg
cgroup_unix_getpeername
cgroup_unix_getsockname
netkit_primary
netkit_peer
trace_kprobe_session
_

std.os.linux.bpf.Attr

容器

第 1587 行

传给 bpf() 系统调用的大型结构体。

字段

map_create: MapCreateAttr
map_elem: MapElemAttr
map_batch: MapBatchAttr
prog_load: ProgLoadAttr
obj: ObjAttr
prog_attach: ProgAttachAttr
test_run: TestRunAttr
get_id: GetIdAttr
info: InfoAttr
query: QueryAttr
raw_tracepoint: RawTracepointAttr
btf_load: BtfLoadAttr
task_fd_query: TaskFdQueryAttr
link_create: LinkCreateAttr
link_update: LinkUpdateAttr
enable_stats: EnableStatsAttr
iter_create: IterCreateAttr

std.os.linux.bpf.B

常量

第 30 行

8 位

std.os.linux.bpf.BPF_F_CLONE

常量

第 247 行

BPF_MAP_CREATE 命令的标志。 为新接受的套接字克隆监听器的映射。

std.os.linux.bpf.BPF_F_MMAPABLE

常量

第 250 行

BPF_MAP_CREATE 命令的标志。启用 BPF 映射的内存映射

std.os.linux.bpf.BPF_F_NO_COMMON_LRU

常量

第 216 行

BPF_MAP_CREATE 命令的标志。不在 BPF_MAP_TYPE_LRU_[PERCPU_]HASH 映射中使用单个共享 LRU 列表,而改用各 CPU 独立的 LRU 列表, 获得更好的伸缩性和性能。注意,LRU 节点,包括空闲节点, 不能在不同 LRU 列表之间移动。

std.os.linux.bpf.BPF_F_NO_PREALLOC

常量

第 210 行

BPF_MAP_CREATE 命令的标志 */

std.os.linux.bpf.BPF_F_NUMA_NODE

常量

第 219 行

BPF_MAP_CREATE 命令的标志:创建映射时指定 NUMA 节点。

std.os.linux.bpf.BPF_F_RDONLY

常量

第 223 行

BPF_MAP_CREATE 命令的标志。用于从系统调用侧读取 BPF 对象的访问标志

std.os.linux.bpf.BPF_F_RDONLY_PROG

常量

第 239 行

BPF_MAP_CREATE 命令的标志:从程序端访问 BPF 对象时使用

std.os.linux.bpf.BPF_F_STACK_BUILD_ID

常量

第 231 行

BPF_MAP_CREATE 命令的标志。用于 stack_map, 存储 build_id+offset 而不是指针。

std.os.linux.bpf.BPF_F_WRONLY

常量

第 227 行

BPF_MAP_CREATE 命令的标志。 控制系统调用端对 BPF 对象的写访问。

std.os.linux.bpf.BPF_F_WRONLY_PROG

常量

第 243 行

BPF_MAP_CREATE 命令的标志:从程序端访问 BPF 对象时使用

std.os.linux.bpf.BPF_F_ZERO_SEED

常量

第 235 行

BPF_MAP_CREATE 命令的标志。将哈希函数种子初始化为零。 仅应在测试时使用。

std.os.linux.bpf.btf

别名

第 12 行

别名目标 std.os.linux.bpf.btf

std.os.linux.bpf.BtfLoadAttr

容器

第 1506 行

Cmd.btf_load 命令使用的结构体

字段

btf: u64
btf_log_buf: u64
btf_size: u32
btf_log_size: u32
btf_log_level: u32

std.os.linux.bpf.CALL

常量

第 126 行

函数调用

std.os.linux.bpf.Cmd

容器

第 937 行

字段

map_create

创建映射,并返回引用该映射的文件描述符。 新文件描述符自动启用执行时关闭 标志。

使用 MapCreateAttr。

map_lookup_elem

按键在指定映射中查找元素并返回其值。

使用 MapElemAttr

map_update_elem

在指定映射中创建或更新元素(键值对)。

使用 MapElemAttr

map_delete_elem

按键查找并删除指定映射中的元素。

使用 MapElemAttr

map_get_next_key

按键在指定映射中查找元素,并返回下一个元素的键。

prog_load

验证并加载 eBPF 程序,返回与该程序关联的 新文件描述符。新文件描述符会自动启用 执行时关闭标志。

使用 ProgLoadAttr。

obj_pin

将映射或 eBPF 程序固定到最小 BPF 文件系统中的路径

使用 ObjAttr

obj_get

获取固定到指定路径的 BPF 对象的文件描述符

使用 ObjAttr

prog_attach

使用 ProgAttachAttr

prog_detach

使用 ProgAttachAttr

prog_test_run

使用 TestRunAttr

prog_get_next_id

使用 GetIdAttr

map_get_next_id

使用 GetIdAttr

prog_get_fd_by_id

使用 GetIdAttr

map_get_fd_by_id

使用 GetIdAttr

obj_get_info_by_fd

使用 InfoAttr

prog_query

使用 QueryAttr

raw_tracepoint_open

使用 RawTracepointAttr

btf_load

使用 BtfLoadAttr

btf_get_fd_by_id

使用 GetIdAttr

task_fd_query

使用 TaskFdQueryAttr

map_lookup_and_delete_elem

使用 MapElemAttr

map_freeze
btf_get_next_id

使用 GetIdAttr

map_lookup_batch

使用 MapBatchAttr

map_lookup_and_delete_batch

使用 MapBatchAttr

map_update_batch

使用 MapBatchAttr

map_delete_batch

使用 MapBatchAttr

link_create

使用 LinkCreateAttr

link_update

使用 LinkUpdateAttr

link_get_fd_by_id

使用 GetIdAttr

link_get_next_id

使用 GetIdAttr

enable_stats

使用 EnableStatsAttr

iter_create

使用 IterCreateAttr

link_detach
_

std.os.linux.bpf.DIV

常量

第 45 行

std.os.linux.bpf.DW

常量

第 32 行

64 位

std.os.linux.bpf.EnableStatsAttr

容器

第 1576 行

Cmd.enable_stats 命令使用的结构体

字段

type: u32

std.os.linux.bpf.END

常量

第 93 行

字节序转换标志:

std.os.linux.bpf.errno

别名

第 2 行

别名目标 std.os.linux.errno

std.os.linux.bpf.EXIST

常量

第 204 行

BPF_MAP_UPDATE_ELEM 命令的标志:更新现有元素

std.os.linux.bpf.EXIT

常量

第 129 行

函数返回

std.os.linux.bpf.expect

别名

第 6 行

别名目标 std.testing.expect

std.os.linux.bpf.expect_opcode

函数

第 823 行

fn expect_opcode(code: u8, insn: Insn) !void

参数

code: u8
insn: Insn

std.os.linux.bpf.expectEqual

别名

第 4 行

别名目标 std.testing.expectEqual

std.os.linux.bpf.expectError

别名

第 5 行

别名目标 std.testing.expectError

std.os.linux.bpf.F_ALLOW_MULTI

常量

第 137 行

prog_attach 命令的标志。若子 cgroup 安装了某个 bpf 程序,则该 cgroup 的程序会与本 cgroup 中的程序一起执行。

std.os.linux.bpf.F_ALLOW_OVERRIDE

常量

第 133 行

prog_attach 命令的标志。若子 cgroup 安装了某个 bpf 程序,则本 cgroup 中的程序让位于子 cgroup 程序。

std.os.linux.bpf.F_ANY_ALIGNMENT

常量

第 156 行

如果在 BPF_PROF_LOAD 命令中使用 BPF_F_ANY_ALIGNMENT,验证器将 允许任意对齐。在对加载和存储具有严格对齐 要求的平台上,例如 sparc 和 mips,验证器会 验证所有加载和存储都能证明符合此要求。此 标志关闭该检查及其强制约束。

它主要用于测试:当我们希望验证上下文和 内存访问相关行为,却因未对齐访问 而先触发了对齐检查,未能到达所关注的检查时使用。

std.os.linux.bpf.F_LOCK

常量

第 207 行

BPF_MAP_UPDATE_ELEM 命令的标志。使用自旋锁的 map_lookup/map_update

std.os.linux.bpf.F_REPLACE

常量

第 140 行

prog_attach 命令的标志。

std.os.linux.bpf.F_SLEEPABLE

常量

第 180 行

如果在 BPF_PROG_LOAD 命令中使用 BPF_F_SLEEPABLE,验证器将 限制此类程序使用映射和辅助函数。可休眠的 BPF 程序 只能附加到内核执行上下文允许休眠的钩子。 这类程序允许使用可能休眠的辅助函数,例如 bpf_copy_from_user()。

std.os.linux.bpf.F_STRICT_ALIGNMENT

常量

第 145 行

如果在 BPF_PROG_LOAD 命令中使用 BPF_F_STRICT_ALIGNMENT,验证器 将严格检查对齐方式,等同于内核构建时未设置 CONFIG_EFFICIENT_UNALIGNED_ACCESS,且 NET_IP_ALIGN 定义为 2。

std.os.linux.bpf.F_TEST_RND_HI32

常量

第 173 行

BPF_F_TEST_RND_HI32 用于 BPF_PROG_LOAD 命令的测试。 验证器会分析子寄存器的定义与使用,并识别那些定义仅影响低 32 位、而高 32 位之后不会通过隐式零扩展被引用的指令。因此,验证器会通知 JIT 后端:对这些指令可以忽略高 32 位的清零操作。这能为某些后端省去大量代码生成工作。 不过,某些架构并不需要此优化,例如 x86_64、arm64 等;其 JIT 后端因此没有使用验证器的分析结果。但我们希望能够验证上述优化在 x86_64 上是否正确,因为测试套件经常在该架构上运行。

因此引入了此标志。设置后,验证器会随机化那些已被判定为可以安全忽略高位的指令的高 32 位。若验证器分析有误,这种随机化就会导致回归测试失败,从而暴露错误。

std.os.linux.bpf.fd_t

别名

第 9 行

别名目标 std.os.linux.fd_t

std.os.linux.bpf.FROM_BE

别名

第 101 行

别名目标 std.os.linux.bpf.TO_BE

std.os.linux.bpf.FROM_LE

别名

第 100 行

别名目标 std.os.linux.bpf.TO_LE

std.os.linux.bpf.GetIdAttr

容器

第 1469 行

Cmd.get_id 命令使用的结构体

字段

id: extern union {
    start_id: u32,
    prog_id: u32,
    map_id: u32,
    btf_id: u32,
    link_id: u32,
}
next_id: u32
open_flags: u32

std.os.linux.bpf.H

常量

第 28 行

16 位

std.os.linux.bpf.Helper

容器

第 254 行

这些值对应 BPF 程序环境中的“系统调用”, 各项文档均位于 std.os.linux.BPF.kern。

字段

unspec
map_lookup_elem
map_update_elem
map_delete_elem
probe_read
ktime_get_ns
trace_printk
get_prandom_u32
get_smp_processor_id
skb_store_bytes
l3_csum_replace
l4_csum_replace
tail_call
clone_redirect
get_current_pid_tgid
get_current_uid_gid
get_current_comm
get_cgroup_classid
skb_vlan_push
skb_vlan_pop
skb_get_tunnel_key
skb_set_tunnel_key
perf_event_read
redirect
get_route_realm
perf_event_output
skb_load_bytes
get_stackid
csum_diff
skb_get_tunnel_opt
skb_set_tunnel_opt
skb_change_proto
skb_change_type
skb_under_cgroup
get_hash_recalc
get_current_task
probe_write_user
current_task_under_cgroup
skb_change_tail
skb_pull_data
csum_update
set_hash_invalid
get_numa_node_id
skb_change_head
xdp_adjust_head
probe_read_str
get_socket_cookie
get_socket_uid
set_hash
setsockopt
skb_adjust_room
redirect_map
sk_redirect_map
sock_map_update
xdp_adjust_meta
perf_event_read_value
perf_prog_read_value
getsockopt
override_return
sock_ops_cb_flags_set
msg_redirect_map
msg_apply_bytes
msg_cork_bytes
msg_pull_data
bind
xdp_adjust_tail
skb_get_xfrm_state
get_stack
skb_load_bytes_relative
fib_lookup
sock_hash_update
msg_redirect_hash
sk_redirect_hash
lwt_push_encap
lwt_seg6_store_bytes
lwt_seg6_adjust_srh
lwt_seg6_action
rc_repeat
rc_keydown
skb_cgroup_id
get_current_cgroup_id
get_local_storage
sk_select_reuseport
skb_ancestor_cgroup_id
sk_lookup_tcp
sk_lookup_udp
sk_release
map_push_elem
map_pop_elem
map_peek_elem
msg_push_data
msg_pop_data
rc_pointer_rel
spin_lock
spin_unlock
sk_fullsock
tcp_sock
skb_ecn_set_ce
get_listener_sock
skc_lookup_tcp
tcp_check_syncookie
sysctl_get_name
sysctl_get_current_value
sysctl_get_new_value
sysctl_set_new_value
strtol
strtoul
sk_storage_get
sk_storage_delete
send_signal
tcp_gen_syncookie
skb_output
probe_read_user
probe_read_kernel
probe_read_user_str
probe_read_kernel_str
tcp_send_ack
send_signal_thread
jiffies64
read_branch_records
get_ns_current_pid_tgid
xdp_output
get_netns_cookie
get_current_ancestor_cgroup_id
sk_assign
ktime_get_boot_ns
seq_printf
seq_write
sk_cgroup_id
sk_ancestor_cgroup_id
ringbuf_output
ringbuf_reserve
ringbuf_submit
ringbuf_discard
ringbuf_query
csum_level
skc_to_tcp6_sock
skc_to_tcp_sock
skc_to_tcp_timewait_sock
skc_to_tcp_request_sock
skc_to_udp6_sock
get_task_stack
load_hdr_opt
store_hdr_opt
reserve_hdr_opt
inode_storage_get
inode_storage_delete
d_path
copy_from_user
snprintf_btf
seq_printf_btf
skb_cgroup_classid
redirect_neigh
per_cpu_ptr
this_cpu_ptr
redirect_peer
task_storage_get
task_storage_delete
get_current_task_btf
bprm_opts_set
ktime_get_coarse_ns
ima_inode_hash
sock_from_file
check_mtu
for_each_map_elem
snprintf
sys_bpf
btf_find_by_name_kind
sys_close
timer_init
timer_set_callback
timer_start
timer_cancel
get_func_ip
get_attach_cookie
task_pt_regs
get_branch_snapshot
trace_vprintk
skc_to_unix_sock
kallsyms_lookup_name
find_vma
loop
strncmp
get_func_arg
get_func_ret
get_func_arg_cnt
get_retval
set_retval
xdp_get_buff_len
xdp_load_bytes
xdp_store_bytes
copy_from_user_task
skb_set_tstamp
ima_file_hash
kptr_xchg
map_lookup_percpu_elem
skc_to_mptcp_sock
dynptr_from_mem
ringbuf_reserve_dynptr
ringbuf_submit_dynptr
ringbuf_discard_dynptr
dynptr_read
dynptr_write
dynptr_data
tcp_raw_gen_syncookie_ipv4
tcp_raw_gen_syncookie_ipv6
tcp_raw_check_syncookie_ipv4
tcp_raw_check_syncookie_ipv6
ktime_get_tai_ns
user_ringbuf_drain
cgrp_storage_get
cgrp_storage_delete
_

std.os.linux.bpf.IMM

常量

第 34 行

std.os.linux.bpf.IND

常量

第 36 行

std.os.linux.bpf.InfoAttr

容器

第 1482 行

Cmd.obj_get_info_by_fd 命令使用的结构体

字段

bpf_fd: fd_t
info_len: u32
info: u64

std.os.linux.bpf.Insn

容器

第 473 行

单条 BPF 指令

字段

code: u8
dst: u4
src: u4
off: i16
imm: i32

std.os.linux.bpf.Insn.add

函数

第 577 行

pub fn add(dst: Reg, src: anytype) Insn

参数

dst: Reg

std.os.linux.bpf.Insn.alu

函数

第 563 行

pub fn alu(comptime width: comptime_int, op: AluOp, dst: Reg, src: anytype) Insn

参数

width: comptime_int
op: AluOp
dst: Reg

std.os.linux.bpf.Insn.alu_and

函数

第 597 行

pub fn alu_and(dst: Reg, src: anytype) Insn

参数

dst: Reg

std.os.linux.bpf.Insn.alu_or

函数

第 593 行

pub fn alu_or(dst: Reg, src: anytype) Insn

参数

dst: Reg

std.os.linux.bpf.Insn.AluOp

容器

第 494 行

字段

std.os.linux.bpf.Insn.arsh

函数

第 621 行

pub fn arsh(dst: Reg, src: anytype) Insn

参数

dst: Reg

std.os.linux.bpf.Insn.be

函数

第 793 行

pub fn be(comptime size: Size, dst: Reg) Insn

参数

size: Size
dst: Reg

std.os.linux.bpf.Insn.call

函数

第 797 行

pub fn call(helper: Helper) Insn

参数

helper: Helper

std.os.linux.bpf.Insn.div

函数

第 589 行

pub fn div(dst: Reg, src: anytype) Insn

参数

dst: Reg

std.os.linux.bpf.Insn.endian_swap

函数

第 771 行

fn endian_swap(endian: std.builtin.Endian, comptime size: Size, dst: Reg) Insn

参数

endian: std.builtin.Endian
size: Size
dst: Reg

std.os.linux.bpf.Insn.exit

函数

第 808 行

退出 BPF 程序

pub fn exit() Insn

std.os.linux.bpf.Insn.imm_reg

函数

第 537 行

fn imm_reg(code: u8, dst: Reg, src: anytype, off: i16) Insn

参数

code: u8
dst: Reg
off: i16

std.os.linux.bpf.Insn.ImmOrReg

容器

第 532 行

字段

reg: Reg
imm: i32

std.os.linux.bpf.Insn.ja

函数

第 629 行

pub fn ja(off: i16) Insn

参数

off: i16

std.os.linux.bpf.Insn.jeq

函数

第 633 行

pub fn jeq(dst: Reg, src: anytype, off: i16) Insn

参数

dst: Reg
off: i16

std.os.linux.bpf.Insn.jge

函数

第 641 行

pub fn jge(dst: Reg, src: anytype, off: i16) Insn

参数

dst: Reg
off: i16

std.os.linux.bpf.Insn.jgt

函数

第 637 行

pub fn jgt(dst: Reg, src: anytype, off: i16) Insn

参数

dst: Reg
off: i16

std.os.linux.bpf.Insn.jle

函数

第 649 行

pub fn jle(dst: Reg, src: anytype, off: i16) Insn

参数

dst: Reg
off: i16

std.os.linux.bpf.Insn.jlt

函数

第 645 行

pub fn jlt(dst: Reg, src: anytype, off: i16) Insn

参数

dst: Reg
off: i16

std.os.linux.bpf.Insn.jmp

函数

第 625 行

pub fn jmp(op: JmpOp, dst: Reg, src: anytype, off: i16) Insn

参数

op: JmpOp
dst: Reg
off: i16

std.os.linux.bpf.Insn.JmpOp

容器

第 517 行

字段

std.os.linux.bpf.Insn.jne

函数

第 657 行

pub fn jne(dst: Reg, src: anytype, off: i16) Insn

参数

dst: Reg
off: i16

std.os.linux.bpf.Insn.jset

函数

第 653 行

pub fn jset(dst: Reg, src: anytype, off: i16) Insn

参数

dst: Reg
off: i16

std.os.linux.bpf.Insn.jsge

函数

第 665 行

pub fn jsge(dst: Reg, src: anytype, off: i16) Insn

参数

dst: Reg
off: i16

std.os.linux.bpf.Insn.jsgt

函数

第 661 行

pub fn jsgt(dst: Reg, src: anytype, off: i16) Insn

参数

dst: Reg
off: i16

std.os.linux.bpf.Insn.jsle

函数

第 673 行

pub fn jsle(dst: Reg, src: anytype, off: i16) Insn

参数

dst: Reg
off: i16

std.os.linux.bpf.Insn.jslt

函数

第 669 行

pub fn jslt(dst: Reg, src: anytype, off: i16) Insn

参数

dst: Reg
off: i16

std.os.linux.bpf.Insn.ld

函数

第 687 行

fn ld(mode: Mode, size: Size, dst: Reg, src: Reg, imm: i32) Insn

参数

mode: Mode
size: Size
dst: Reg
src: Reg
imm: i32

std.os.linux.bpf.Insn.ld_abs

函数

第 697 行

pub fn ld_abs(size: Size, dst: Reg, src: Reg, imm: i32) Insn

参数

size: Size
dst: Reg
src: Reg
imm: i32

std.os.linux.bpf.Insn.ld_dw1

函数

第 735 行

pub fn ld_dw1(dst: Reg, imm: u64) Insn

参数

dst: Reg
imm: u64

std.os.linux.bpf.Insn.ld_dw2

函数

第 739 行

pub fn ld_dw2(imm: u64) Insn

参数

imm: u64

std.os.linux.bpf.Insn.ld_imm_impl1

函数

第 715 行

fn ld_imm_impl1(dst: Reg, src: Reg, imm: u64) Insn

参数

dst: Reg
src: Reg
imm: u64

std.os.linux.bpf.Insn.ld_imm_impl2

函数

第 725 行

fn ld_imm_impl2(imm: u64) Insn

参数

imm: u64

std.os.linux.bpf.Insn.ld_ind

函数

第 701 行

pub fn ld_ind(size: Size, dst: Reg, src: Reg, imm: i32) Insn

参数

size: Size
dst: Reg
src: Reg
imm: i32

std.os.linux.bpf.Insn.ld_map_fd1

函数

第 743 行

pub fn ld_map_fd1(dst: Reg, map_fd: fd_t) Insn

参数

dst: Reg
map_fd: fd_t

std.os.linux.bpf.Insn.ld_map_fd2

函数

第 747 行

pub fn ld_map_fd2(map_fd: fd_t) Insn

参数

map_fd: fd_t

std.os.linux.bpf.Insn.ldx

函数

第 705 行

pub fn ldx(size: Size, dst: Reg, src: Reg, off: i16) Insn

参数

size: Size
dst: Reg
src: Reg
off: i16

std.os.linux.bpf.Insn.le

函数

第 789 行

pub fn le(comptime size: Size, dst: Reg) Insn

参数

size: Size
dst: Reg

std.os.linux.bpf.Insn.lsh

函数

第 601 行

pub fn lsh(dst: Reg, src: anytype) Insn

参数

dst: Reg

std.os.linux.bpf.Insn.mod

函数

第 613 行

pub fn mod(dst: Reg, src: anytype) Insn

参数

dst: Reg

std.os.linux.bpf.Insn.Mode

容器

第 485 行

字段

imm = IMM
abs = ABS
ind = IND
mem = MEM
len = LEN
msh = MSH

std.os.linux.bpf.Insn.mov

函数

第 573 行

pub fn mov(dst: Reg, src: anytype) Insn

参数

dst: Reg

std.os.linux.bpf.Insn.mul

函数

第 585 行

pub fn mul(dst: Reg, src: anytype) Insn

参数

dst: Reg

std.os.linux.bpf.Insn.neg

函数

第 609 行

pub fn neg(dst: Reg) Insn

参数

dst: Reg

std.os.linux.bpf.Insn.Reg

容器

第 482 行

r0 - r9 是通用 64 位寄存器,r10 指向栈帧

字段

r0
r1
r2
r3
r4
r5
r6
r7
r8
r9
r10

std.os.linux.bpf.Insn.rsh

函数

第 605 行

pub fn rsh(dst: Reg, src: anytype) Insn

参数

dst: Reg

std.os.linux.bpf.Insn.Size

容器

第 510 行

字段

byte = B
half_word = H
word = W
double_word = DW

std.os.linux.bpf.Insn.Source

容器

第 483 行

字段

reg
imm

std.os.linux.bpf.Insn.st

函数

第 751 行

pub fn st(size: Size, dst: Reg, off: i16, imm: i32) Insn

参数

size: Size
dst: Reg
off: i16
imm: i32

std.os.linux.bpf.Insn.stx

函数

第 761 行

pub fn stx(size: Size, dst: Reg, off: i16, src: Reg) Insn

参数

size: Size
dst: Reg
off: i16
src: Reg

std.os.linux.bpf.Insn.sub

函数

第 581 行

pub fn sub(dst: Reg, src: anytype) Insn

参数

dst: Reg

std.os.linux.bpf.Insn.xadd

函数

第 677 行

pub fn xadd(dst: Reg, src: Reg) Insn

参数

dst: Reg
src: Reg

std.os.linux.bpf.Insn.xor

函数

第 617 行

pub fn xor(dst: Reg, src: anytype) Insn

参数

dst: Reg

std.os.linux.bpf.IterCreateAttr

容器

第 1581 行

Cmd.iter_create 命令使用的结构体

字段

link_fd: fd_t
flags: u32

std.os.linux.bpf.JA

常量

第 55 行

std.os.linux.bpf.JEQ

常量

第 56 行

std.os.linux.bpf.JGE

常量

第 58 行

std.os.linux.bpf.JGT

常量

第 57 行

std.os.linux.bpf.JLE

常量

第 111 行

LE 表示无符号 '<=' *

std.os.linux.bpf.JLT

常量

第 108 行

LT 表示无符号 '<'

std.os.linux.bpf.JMP

常量

第 21 行

std.os.linux.bpf.JMP32

常量

第 75 行

字宽度的 jmp 模式

std.os.linux.bpf.JNE

常量

第 105 行

jump != *

std.os.linux.bpf.JSET

常量

第 59 行

std.os.linux.bpf.JSGE

常量

第 117 行

SGE 是有符号的 '>=',对应 x86 的 GE

std.os.linux.bpf.JSGT

常量

第 114 行

SGT 是有符号的 '>',即 x86 中的 GT

std.os.linux.bpf.JSLE

常量

第 123 行

SLE 为有符号 '<='

std.os.linux.bpf.JSLT

常量

第 120 行

SLT 为有符号 '<'

std.os.linux.bpf.K

常量

第 68 行

std.os.linux.bpf.kern

别名

第 13 行

别名目标 std.os.linux.bpf.kern

std.os.linux.bpf.LD

常量

第 16 行

std.os.linux.bpf.LDX

常量

第 17 行

std.os.linux.bpf.LEN

常量

第 38 行

std.os.linux.bpf.LinkCreateAttr

容器

第 1548 行

Cmd.link_create 命令使用的结构体

字段

prog_fd: fd_t

要附加的 eBPF 程序

target_fd: fd_t

要附加到的对象

attach_type: u32
flags: u32

额外标志

std.os.linux.bpf.LinkUpdateAttr

容器

第 1561 行

Cmd.link_update 命令使用的结构体

字段

link_fd: fd_t
new_prog_fd: fd_t

用于更新链接的新程序

flags: u32

额外标志

old_prog_fd: fd_t

预期链接的程序文件描述符, 仅在 flags 中设置 BPF_F_REPLACE 时指定。

std.os.linux.bpf.linux

别名

第 8 行

别名目标 std.os.linux

std.os.linux.bpf.Log

容器

第 1607 行

字段

level: u32
buf: []u8

std.os.linux.bpf.LSH

常量

第 48 行

std.os.linux.bpf.map_create

函数

第 1612 行

pub fn map_create(map_type: MapType, key_size: u32, value_size: u32, max_entries: u32) !fd_t

参数

map_type: MapType
key_size: u32
value_size: u32
max_entries: u32

std.os.linux.bpf.map_delete_elem

函数

第 1681 行

pub fn map_delete_elem(fd: fd_t, key: []const u8) !void

参数

fd: fd_t
key: []const u8

std.os.linux.bpf.map_get_next_key

函数

第 1701 行

pub fn map_get_next_key(fd: fd_t, key: []const u8, next_key: []u8) !bool

参数

fd: fd_t
key: []const u8
next_key: []u8

std.os.linux.bpf.map_lookup_elem

函数

第 1637 行

pub fn map_lookup_elem(fd: fd_t, key: []const u8, value: []u8) !void

参数

fd: fd_t
key: []const u8
value: []u8

std.os.linux.bpf.map_update_elem

函数

第 1658 行

pub fn map_update_elem(fd: fd_t, key: []const u8, value: []const u8, flags: u64) !void

参数

fd: fd_t
key: []const u8
value: []const u8
flags: u64

std.os.linux.bpf.MapBatchAttr

容器

第 1349 行

Cmd.map_*_batch 命令使用的结构体

字段

in_batch: u64

起始批次,为 NULL 时从开头开始

out_batch: u64

输出:下一起始批次

keys: u64
values: u64
count: u32

输入/输出: 输入:键值元素数量。 输出:已填充元素数量。

map_fd: fd_t
elem_flags: u64
flags: u64

std.os.linux.bpf.MapCreateAttr

容器

第 1298 行

Cmd.map_create 命令使用的结构体

字段

map_type: u32

MapType 中的一种

key_size: u32

键的字节大小

value_size: u32

值的大小,单位为字节

max_entries: u32

映射中的最大条目数

map_flags: u32

与 .map_create 相关的标志

inner_map_fd: fd_t

指向内部映射的文件描述符

numa_node: u32

NUMA 节点(仅设置 MapCreateFlags.numa_node 时有效)。

map_name: [obj_name_len]u8
map_ifindex: u32

要在其上创建对象的网络设备接口索引

btf_fd: fd_t

指向 BTF 类型数据的文件描述符

btf_key_type_id: u32

键的 BTF type_id

bpf_value_type_id: u32

值的 BTF type_id

btf_vmlinux_value_type_id: u32

作为映射值存储的内核结构体的 BTF type_id。

std.os.linux.bpf.MapElemAttr

容器

第 1338 行

Cmd.map_*_elem 命令使用的结构体

字段

map_fd: fd_t
key: u64
result: extern union {
    value: u64,
    next_key: u64,
}
flags: u64

std.os.linux.bpf.MapType

容器

第 1060 行

字段

unspec
hash
array
prog_array
perf_event_array
percpu_hash
percpu_array
stack_trace
cgroup_array
lru_hash
lru_percpu_hash
lpm_trie
array_of_maps
hash_of_maps
devmap
sockmap
cpumap
xskmap
sockhash
cgroup_storage_deprecated
reuseport_sockarray
percpu_cgroup_storage
queue
stack
sk_storage
devmap_hash
struct_ops
ringbuf

perf_event_array 的有序、跨 CPU 共享版本,具有类似语义:

  • 变长记录
  • 非阻塞:已满时预留失败
  • 支持内存映射,便于使用并提升速度
  • 新数据通过 epoll 通知,也可忙轮询

环形缓冲区为 BPF 程序提供两组接口:

  • ringbuf_output() 将其他位置的数据复制到环形缓冲区,类似 bpf_perf_event_output()。
  • ringbuf_reserve()/ringbuf_commit()/ringbuf_discard() 将过程分为两步:先预留固定大小空间;成功后程序取得内存块指针,可以通过 commit() 提交或 discard() 丢弃。

ringbuf_output() 会增加一次内存复制,但允许提交事先未知长度的记录,是替换 perf_event_output() 的简单方式。

ringbuf_reserve() 避免额外复制,但要求预先知道内存大小。

ringbuf_query() 用于查询映射属性,目前支持四项:

  • BPF_RB_AVAIL_DATA:环形缓冲区未消费的数据量
  • BPF_RB_RING_SIZE:环形缓冲区大小
  • BPF_RB_CONS_POS/BPF_RB_PROD_POS:分别为消费者和生产者当前逻辑位置

键大小:0 值大小:0 最大条目数:环形缓冲区大小,必须是二的幂

inode_storage
task_storage
bloom_filter
user_ringbuf
cgroup_storage
arena
_

std.os.linux.bpf.MAXINSNS

常量

第 71 行

std.os.linux.bpf.MEM

常量

第 37 行

std.os.linux.bpf.MISC

常量

第 23 行

std.os.linux.bpf.MOD

常量

第 51 行

std.os.linux.bpf.MOV

常量

第 86 行

寄存器到寄存器的 mov

std.os.linux.bpf.MSH

常量

第 39 行

std.os.linux.bpf.MUL

常量

第 44 行

std.os.linux.bpf.NEG

常量

第 50 行

std.os.linux.bpf.NOEXIST

常量

第 201 行

BPF_MAP_UPDATE_ELEM 命令的标志。元素不存在时创建新元素

std.os.linux.bpf.obj_name_len

常量

第 1296 行

std.os.linux.bpf.ObjAttr

容器

第 1422 行

Cmd.obj_* 命令使用的结构体

字段

pathname: u64
bpf_fd: fd_t
file_flags: u32

std.os.linux.bpf.OR

常量

第 46 行

std.os.linux.bpf.pid_t

别名

第 10 行

别名目标 std.os.linux.pid_t

std.os.linux.bpf.prog_load

函数

第 1760 行

pub fn prog_load( prog_type: ProgType, insns: []const Insn, log: ?*Log, license: []const u8, kern_version: u32, flags: u32, ) !fd_t

参数

prog_type: ProgType
insns: []const Insn
log: ?*Log
license: []const u8
kern_version: u32
flags: u32

std.os.linux.bpf.ProgAttachAttr

容器

第 1429 行

Cmd.prog_attach/detach 命令使用的结构体。

字段

target_fd: fd_t

要附加到的容器对象

attach_bpf_fd: fd_t

要附加的 eBPF 程序

attach_type: u32
attach_flags: u32
replace_bpf_fd: fd_t

使用 .replace 时,要替换的先前附加 eBPF 程序

std.os.linux.bpf.ProgLoadAttr

容器

第 1368 行

Cmd.prog_load 命令使用的结构体

字段

prog_type: u32

ProgType 中的一项

insn_cnt: u32
insns: u64
license: u64
log_level: u32

验证器的详细程度

log_size: u32

用户缓冲区大小

log_buf: u64

用户提供的缓冲区

kern_version: u32

未使用

prog_flags: u32
prog_name: [obj_name_len]u8
prog_ifindex: u32

要准备的网络设备的 ifindex。

expected_attach_type: u32

某些程序类型必须在加载时知道预期附加类型, 以验证程序中特定于该附加类型的部分 (上下文访问、允许的辅助函数等)。

prog_btf_fd: fd_t

指向 BTF 类型数据的 fd

func_info_rec_size: u32

用户空间的 bpf_func_info 大小

func_info: u64
func_info_cnt: u32

bpf_func_info 记录的数量

line_info_rec_size: u32

用户空间 bpf_line_info 的大小

line_info: u64
line_info_cnt: u32

bpf_line_info 记录数量

attact_btf_id: u32

要附加的内核态 BTF 类型标识符

attach_prog_id: u32

0 表示附加到 vmlinux

std.os.linux.bpf.ProgType

容器

第 1133 行

字段

unspec
socket_filter

上下文类型:__sk_buff

kprobe

上下文类型:bpf_user_pt_regs_t

sched_cls

上下文类型:__sk_buff

sched_act

上下文类型:__sk_buff

tracepoint

上下文类型:u64

xdp

上下文类型:xdp_md

perf_event

上下文类型:bpf_perf_event_data

cgroup_skb

上下文类型:__sk_buff

cgroup_sock

上下文类型:bpf_sock

lwt_in

上下文类型:__sk_buff

lwt_out

上下文类型:__sk_buff

lwt_xmit

上下文类型:__sk_buff

sock_ops

上下文类型:bpf_sock_ops

sk_skb

上下文类型:__sk_buff

cgroup_device

上下文类型:bpf_cgroup_dev_ctx

sk_msg

上下文类型:sk_msg_md

raw_tracepoint

上下文类型:bpf_raw_tracepoint_args

cgroup_sock_addr

上下文类型:bpf_sock_addr

lwt_seg6local

上下文类型:__sk_buff

lirc_mode2

上下文类型:u32

sk_reuseport

上下文类型:sk_reuseport_md

flow_dissector

上下文类型:__sk_buff

cgroup_sysctl

上下文类型:bpf_sysctl

raw_tracepoint_writable

上下文类型:bpf_raw_tracepoint_args

cgroup_sockopt

上下文类型:bpf_sockopt

tracing

上下文类型:void *

struct_ops

上下文类型:void *

ext

上下文类型:void *

lsm

上下文类型:void *

sk_lookup

上下文类型:bpf_sk_lookup

syscall

上下文类型:void *

netfilter

上下文类型:bpf_nf_ctx

_

std.os.linux.bpf.PSEUDO_CALL

常量

第 195 行

当 bpf_call->src_reg == BPF_PSEUDO_CALL 时,bpf_call->imm 是 相对于程序计数器的另一个 BPF 函数的偏移量。

std.os.linux.bpf.PSEUDO_MAP_FD

常量

第 190 行

BPF ldimm64 的 insn[0].src_reg != 0 时,可以有两种扩展: insn[0].src_reg: BPF_PSEUDO_MAP_FD BPF_PSEUDO_MAP_VALUE insn[0].imm: 映射 fd 映射 fd insn[1].imm: 0 值内偏移 insn[0].off: 0 0 insn[1].off: 0 0 ldimm64 重写: 映射地址 map[0]+offset 的地址 验证器类型: CONST_PTR_TO_MAP PTR_TO_MAP_VALUE

std.os.linux.bpf.PSEUDO_MAP_VALUE

常量

第 191 行

std.os.linux.bpf.QueryAttr

容器

第 1489 行

Cmd.prog_query 命令使用的结构体

字段

target_fd: fd_t

要查询的容器对象

attach_type: u32
query_flags: u32
attach_flags: u32
prog_ids: u64
prog_cnt: u32

std.os.linux.bpf.RawTracepointAttr

容器

第 1500 行

Cmd.raw_tracepoint_open 命令使用的结构体

字段

name: u64
prog_fd: fd_t

std.os.linux.bpf.RET

常量

第 22 行

std.os.linux.bpf.RSH

常量

第 49 行

std.os.linux.bpf.ST

常量

第 18 行

std.os.linux.bpf.std

别名

第 1 行

别名目标 std

std.os.linux.bpf.STX

常量

第 19 行

std.os.linux.bpf.SUB

常量

第 43 行

std.os.linux.bpf.TaskFdQueryAttr

容器

第 1515 行

Cmd.task_fd_query 使用的结构体

字段

pid: pid_t

输入:pid

fd: fd_t

输入:fd

flags: u32

输入:flags

buf_len: u32

输入/输出:缓冲区长度

buf: u64

输入/输出: 跟踪点的 tp_name kprobe 的 symbol uprobe 的 filename

prog_id: u32

输出:prod_id

fd_type: u32

输出:BPF_FD_TYPE

probe_offset: u64

输出:probe_offset

probe_addr: u64

输出:probe_addr

std.os.linux.bpf.TAX

常量

第 63 行

将 A 复制到 X

std.os.linux.bpf.TestRunAttr

容器

第 1445 行

Cmd.prog_test_run 命令使用的结构体

字段

prog_fd: fd_t
retval: u32
data_size_in: u32

输入:data_in 的长度

data_size_out: u32

输入/输出:data_out 的长度。若 data_out 太小,则返回 ENOSPC。

data_in: u64
data_out: u64
repeat: u32
duration: u32
ctx_size_in: u32

输入:ctx_in 的长度

ctx_size_out: u32

输入/输出:ctx_out 的长度。ctx_out 过小时返回 ENOSPC。

ctx_in: u64
ctx_out: u64

std.os.linux.bpf.TO_BE

常量

第 99 行

转换为大端序

std.os.linux.bpf.TO_LE

常量

第 96 行

转换为小端序 */

std.os.linux.bpf.TXA

常量

第 65 行

将 X 复制到 A

std.os.linux.bpf.unexpectedErrno

别名

第 3 行

别名目标 std.posix.unexpectedErrno

std.os.linux.bpf.W

常量

第 26 行

32 位

std.os.linux.bpf.X

常量

第 69 行

std.os.linux.bpf.XADD

常量

第 82 行

排他添加

std.os.linux.bpf.XOR

常量

第 52 行

源码

std/os/linux/bpf.zig

const std = @import("../../std.zig");
const errno = linux.errno;
const unexpectedErrno = std.posix.unexpectedErrno;
const expectEqual = std.testing.expectEqual;
const expectError = std.testing.expectError;
const expect = std.testing.expect;

const linux = std.os.linux;
const fd_t = linux.fd_t;
const pid_t = linux.pid_t;

pub const btf = @import("bpf/btf.zig");
pub const kern = @import("bpf/kern.zig");

// 指令类别
pub const LD = 0x00;
pub const LDX = 0x01;
pub const ST = 0x02;
pub const STX = 0x03;
pub const ALU = 0x04;
pub const JMP = 0x05;
pub const RET = 0x06;
pub const MISC = 0x07;

/// 32 位
pub const W = 0x00;
/// 16 位
pub const H = 0x08;
/// 8 位
pub const B = 0x10;
/// 64 位
pub const DW = 0x18;

pub const IMM = 0x00;
pub const ABS = 0x20;
pub const IND = 0x40;
pub const MEM = 0x60;
pub const LEN = 0x80;
pub const MSH = 0xa0;

// ALU 字段
pub const ADD = 0x00;
pub const SUB = 0x10;
pub const MUL = 0x20;
pub const DIV = 0x30;
pub const OR = 0x40;
pub const AND = 0x50;
pub const LSH = 0x60;
pub const RSH = 0x70;
pub const NEG = 0x80;
pub const MOD = 0x90;
pub const XOR = 0xa0;

// jmp 字段
pub const JA = 0x00;
pub const JEQ = 0x10;
pub const JGT = 0x20;
pub const JGE = 0x30;
pub const JSET = 0x40;

// 其他字段
/// 将 A 复制到 X
pub const TAX = 0x00;
/// 将 X 复制到 A
pub const TXA = 0x80;

// #define BPF_SRC(code)   ((code) & 0x08)
pub const K = 0x00;
pub const X = 0x08;

pub const MAXINSNS = 4096;

// 指令类别
/// 字宽度的 jmp 模式
pub const JMP32 = 0x06;

/// 双字宽度的 alu 模式
pub const ALU64 = 0x07;

// ld/ldx 字段
/// 排他添加
pub const XADD = 0xc0;

// alu/jmp 字段
/// 寄存器到寄存器的 mov
pub const MOV = 0xb0;

/// 进行符号扩展的算术右移 */
pub const ARSH = 0xc0;

// 改变寄存器的字节序
/// 字节序转换标志:
pub const END = 0xd0;

/// 转换为小端序 */
pub const TO_LE = 0x00;

/// 转换为大端序
pub const TO_BE = 0x08;
pub const FROM_LE = TO_LE;
pub const FROM_BE = TO_BE;

// jmp 编码
/// jump != *
pub const JNE = 0x50;

/// LT 表示无符号 '<'
pub const JLT = 0xa0;

/// LE 表示无符号 '<=' *
pub const JLE = 0xb0;

/// SGT 是有符号的 '>',即 x86 中的 GT
pub const JSGT = 0x60;

/// SGE 是有符号的 '>=',对应 x86 的 GE
pub const JSGE = 0x70;

/// SLT 为有符号 '<'
pub const JSLT = 0xc0;

/// SLE 为有符号 '<='
pub const JSLE = 0xd0;

/// 函数调用
pub const CALL = 0x80;

/// 函数返回
pub const EXIT = 0x90;

/// prog_attach 命令的标志。若子 cgroup 安装了某个 bpf 程序,则本 cgroup 中的程序让位于子 cgroup 程序。
///
pub const F_ALLOW_OVERRIDE = 0x1;

/// prog_attach 命令的标志。若子 cgroup 安装了某个 bpf 程序,则该 cgroup 的程序会与本 cgroup 中的程序一起执行。
///
pub const F_ALLOW_MULTI = 0x2;

/// prog_attach 命令的标志。
pub const F_REPLACE = 0x4;

/// 如果在 BPF_PROG_LOAD 命令中使用 BPF_F_STRICT_ALIGNMENT,验证器
/// 将严格检查对齐方式,等同于内核构建时未设置
/// CONFIG_EFFICIENT_UNALIGNED_ACCESS,且 NET_IP_ALIGN 定义为 2。
pub const F_STRICT_ALIGNMENT = 0x1;

/// 如果在 BPF_PROF_LOAD 命令中使用 BPF_F_ANY_ALIGNMENT,验证器将
/// 允许任意对齐。在对加载和存储具有严格对齐
/// 要求的平台上,例如 sparc 和 mips,验证器会
/// 验证所有加载和存储都能证明符合此要求。此
/// 标志关闭该检查及其强制约束。
///
/// 它主要用于测试:当我们希望验证上下文和
/// 内存访问相关行为,却因未对齐访问
/// 而先触发了对齐检查,未能到达所关注的检查时使用。
pub const F_ANY_ALIGNMENT = 0x2;

/// BPF_F_TEST_RND_HI32 用于 BPF_PROG_LOAD 命令的测试。
/// 验证器会分析子寄存器的定义与使用,并识别那些定义仅影响低 32 位、而高 32 位之后不会通过隐式零扩展被引用的指令。因此,验证器会通知 JIT 后端:对这些指令可以忽略高 32 位的清零操作。这能为某些后端省去大量代码生成工作。
/// 不过,某些架构并不需要此优化,例如 x86_64、arm64 等;其 JIT 后端因此没有使用验证器的分析结果。但我们希望能够验证上述优化在 x86_64 上是否正确,因为测试套件经常在该架构上运行。
///
/// 因此引入了此标志。设置后,验证器会随机化那些已被判定为可以安全忽略高位的指令的高 32 位。若验证器分析有误,这种随机化就会导致回归测试失败,从而暴露错误。
///
///
///
///
///
///
///
///
///
///
pub const F_TEST_RND_HI32 = 0x4;

/// 如果在 BPF_PROG_LOAD 命令中使用 BPF_F_SLEEPABLE,验证器将
/// 限制此类程序使用映射和辅助函数。可休眠的 BPF 程序
/// 只能附加到内核执行上下文允许休眠的钩子。
/// 这类程序允许使用可能休眠的辅助函数,例如
/// bpf_copy_from_user()。
pub const F_SLEEPABLE = 0x10;

/// BPF ldimm64 的 insn[0].src_reg != 0 时,可以有两种扩展:
/// insn[0].src_reg:  BPF_PSEUDO_MAP_FD   BPF_PSEUDO_MAP_VALUE
/// insn[0].imm:      映射 fd             映射 fd
/// insn[1].imm:      0                   值内偏移
/// insn[0].off:      0                   0
/// insn[1].off:      0                   0
/// ldimm64 重写:    映射地址            map[0]+offset 的地址
/// 验证器类型:     CONST_PTR_TO_MAP    PTR_TO_MAP_VALUE
pub const PSEUDO_MAP_FD = 1;
pub const PSEUDO_MAP_VALUE = 2;

/// 当 bpf_call->src_reg == BPF_PSEUDO_CALL 时,bpf_call->imm 是
/// 相对于程序计数器的另一个 BPF 函数的偏移量。
pub const PSEUDO_CALL = 1;

/// BPF_MAP_UPDATE_ELEM 命令的标志:创建新元素或更新现有元素。
pub const ANY = 0;

/// BPF_MAP_UPDATE_ELEM 命令的标志。元素不存在时创建新元素
pub const NOEXIST = 1;

/// BPF_MAP_UPDATE_ELEM 命令的标志:更新现有元素
pub const EXIST = 2;

/// BPF_MAP_UPDATE_ELEM 命令的标志。使用自旋锁的 map_lookup/map_update
pub const F_LOCK = 4;

/// BPF_MAP_CREATE 命令的标志 */
pub const BPF_F_NO_PREALLOC = 0x1;

/// BPF_MAP_CREATE 命令的标志。不在 BPF_MAP_TYPE_LRU_[PERCPU_]HASH
/// 映射中使用单个共享 LRU 列表,而改用各 CPU 独立的 LRU 列表,
/// 获得更好的伸缩性和性能。注意,LRU 节点,包括空闲节点,
/// 不能在不同 LRU 列表之间移动。
pub const BPF_F_NO_COMMON_LRU = 0x2;

/// BPF_MAP_CREATE 命令的标志:创建映射时指定 NUMA 节点。
pub const BPF_F_NUMA_NODE = 0x4;

/// BPF_MAP_CREATE 命令的标志。用于从系统调用侧读取
/// BPF 对象的访问标志
pub const BPF_F_RDONLY = 0x8;

/// BPF_MAP_CREATE 命令的标志。
/// 控制系统调用端对 BPF 对象的写访问。
pub const BPF_F_WRONLY = 0x10;

/// BPF_MAP_CREATE 命令的标志。用于 stack_map,
/// 存储 build_id+offset 而不是指针。
pub const BPF_F_STACK_BUILD_ID = 0x20;

/// BPF_MAP_CREATE 命令的标志。将哈希函数种子初始化为零。
/// 仅应在测试时使用。
pub const BPF_F_ZERO_SEED = 0x40;

/// BPF_MAP_CREATE 命令的标志:从程序端访问 BPF 对象时使用
///
pub const BPF_F_RDONLY_PROG = 0x80;

/// BPF_MAP_CREATE 命令的标志:从程序端访问 BPF 对象时使用
///
pub const BPF_F_WRONLY_PROG = 0x100;

/// BPF_MAP_CREATE 命令的标志。
/// 为新接受的套接字克隆监听器的映射。
pub const BPF_F_CLONE = 0x200;

/// BPF_MAP_CREATE 命令的标志。启用 BPF 映射的内存映射
pub const BPF_F_MMAPABLE = 0x400;

/// 这些值对应 BPF 程序环境中的“系统调用”,
/// 各项文档均位于 std.os.linux.BPF.kern。
pub const Helper = enum(i32) {
    unspec,
    map_lookup_elem,
    map_update_elem,
    map_delete_elem,
    probe_read,
    ktime_get_ns,
    trace_printk,
    get_prandom_u32,
    get_smp_processor_id,
    skb_store_bytes,
    l3_csum_replace,
    l4_csum_replace,
    tail_call,
    clone_redirect,
    get_current_pid_tgid,
    get_current_uid_gid,
    get_current_comm,
    get_cgroup_classid,
    skb_vlan_push,
    skb_vlan_pop,
    skb_get_tunnel_key,
    skb_set_tunnel_key,
    perf_event_read,
    redirect,
    get_route_realm,
    perf_event_output,
    skb_load_bytes,
    get_stackid,
    csum_diff,
    skb_get_tunnel_opt,
    skb_set_tunnel_opt,
    skb_change_proto,
    skb_change_type,
    skb_under_cgroup,
    get_hash_recalc,
    get_current_task,
    probe_write_user,
    current_task_under_cgroup,
    skb_change_tail,
    skb_pull_data,
    csum_update,
    set_hash_invalid,
    get_numa_node_id,
    skb_change_head,
    xdp_adjust_head,
    probe_read_str,
    get_socket_cookie,
    get_socket_uid,
    set_hash,
    setsockopt,
    skb_adjust_room,
    redirect_map,
    sk_redirect_map,
    sock_map_update,
    xdp_adjust_meta,
    perf_event_read_value,
    perf_prog_read_value,
    getsockopt,
    override_return,
    sock_ops_cb_flags_set,
    msg_redirect_map,
    msg_apply_bytes,
    msg_cork_bytes,
    msg_pull_data,
    bind,
    xdp_adjust_tail,
    skb_get_xfrm_state,
    get_stack,
    skb_load_bytes_relative,
    fib_lookup,
    sock_hash_update,
    msg_redirect_hash,
    sk_redirect_hash,
    lwt_push_encap,
    lwt_seg6_store_bytes,
    lwt_seg6_adjust_srh,
    lwt_seg6_action,
    rc_repeat,
    rc_keydown,
    skb_cgroup_id,
    get_current_cgroup_id,
    get_local_storage,
    sk_select_reuseport,
    skb_ancestor_cgroup_id,
    sk_lookup_tcp,
    sk_lookup_udp,
    sk_release,
    map_push_elem,
    map_pop_elem,
    map_peek_elem,
    msg_push_data,
    msg_pop_data,
    rc_pointer_rel,
    spin_lock,
    spin_unlock,
    sk_fullsock,
    tcp_sock,
    skb_ecn_set_ce,
    get_listener_sock,
    skc_lookup_tcp,
    tcp_check_syncookie,
    sysctl_get_name,
    sysctl_get_current_value,
    sysctl_get_new_value,
    sysctl_set_new_value,
    strtol,
    strtoul,
    sk_storage_get,
    sk_storage_delete,
    send_signal,
    tcp_gen_syncookie,
    skb_output,
    probe_read_user,
    probe_read_kernel,
    probe_read_user_str,
    probe_read_kernel_str,
    tcp_send_ack,
    send_signal_thread,
    jiffies64,
    read_branch_records,
    get_ns_current_pid_tgid,
    xdp_output,
    get_netns_cookie,
    get_current_ancestor_cgroup_id,
    sk_assign,
    ktime_get_boot_ns,
    seq_printf,
    seq_write,
    sk_cgroup_id,
    sk_ancestor_cgroup_id,
    ringbuf_output,
    ringbuf_reserve,
    ringbuf_submit,
    ringbuf_discard,
    ringbuf_query,
    csum_level,
    skc_to_tcp6_sock,
    skc_to_tcp_sock,
    skc_to_tcp_timewait_sock,
    skc_to_tcp_request_sock,
    skc_to_udp6_sock,
    get_task_stack,
    load_hdr_opt,
    store_hdr_opt,
    reserve_hdr_opt,
    inode_storage_get,
    inode_storage_delete,
    d_path,
    copy_from_user,
    snprintf_btf,
    seq_printf_btf,
    skb_cgroup_classid,
    redirect_neigh,
    per_cpu_ptr,
    this_cpu_ptr,
    redirect_peer,
    task_storage_get,
    task_storage_delete,
    get_current_task_btf,
    bprm_opts_set,
    ktime_get_coarse_ns,
    ima_inode_hash,
    sock_from_file,
    check_mtu,
    for_each_map_elem,
    snprintf,
    sys_bpf,
    btf_find_by_name_kind,
    sys_close,
    timer_init,
    timer_set_callback,
    timer_start,
    timer_cancel,
    get_func_ip,
    get_attach_cookie,
    task_pt_regs,
    get_branch_snapshot,
    trace_vprintk,
    skc_to_unix_sock,
    kallsyms_lookup_name,
    find_vma,
    loop,
    strncmp,
    get_func_arg,
    get_func_ret,
    get_func_arg_cnt,
    get_retval,
    set_retval,
    xdp_get_buff_len,
    xdp_load_bytes,
    xdp_store_bytes,
    copy_from_user_task,
    skb_set_tstamp,
    ima_file_hash,
    kptr_xchg,
    map_lookup_percpu_elem,
    skc_to_mptcp_sock,
    dynptr_from_mem,
    ringbuf_reserve_dynptr,
    ringbuf_submit_dynptr,
    ringbuf_discard_dynptr,
    dynptr_read,
    dynptr_write,
    dynptr_data,
    tcp_raw_gen_syncookie_ipv4,
    tcp_raw_gen_syncookie_ipv6,
    tcp_raw_check_syncookie_ipv4,
    tcp_raw_check_syncookie_ipv6,
    ktime_get_tai_ns,
    user_ringbuf_drain,
    cgrp_storage_get,
    cgrp_storage_delete,
    _,
};

// TODO: 确定此位布局是否同时适用于小端和大端系统
//
/// 单条 BPF 指令
pub const Insn = packed struct {
    code: u8,
    dst: u4,
    src: u4,
    off: i16,
    imm: i32,

    /// r0 - r9 是通用 64 位寄存器,r10 指向栈帧
    ///
    pub const Reg = enum(u4) { r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10 };
    const Source = enum(u1) { reg, imm };

    const Mode = enum(u8) {
        imm = IMM,
        abs = ABS,
        ind = IND,
        mem = MEM,
        len = LEN,
        msh = MSH,
    };

    pub const AluOp = enum(u8) {
        add = ADD,
        sub = SUB,
        mul = MUL,
        div = DIV,
        alu_or = OR,
        alu_and = AND,
        lsh = LSH,
        rsh = RSH,
        neg = NEG,
        mod = MOD,
        xor = XOR,
        mov = MOV,
        arsh = ARSH,
    };

    pub const Size = enum(u8) {
        byte = B,
        half_word = H,
        word = W,
        double_word = DW,
    };

    pub const JmpOp = enum(u8) {
        ja = JA,
        jeq = JEQ,
        jgt = JGT,
        jge = JGE,
        jset = JSET,
        jlt = JLT,
        jle = JLE,
        jne = JNE,
        jsgt = JSGT,
        jsge = JSGE,
        jslt = JSLT,
        jsle = JSLE,
    };

    const ImmOrReg = union(Source) {
        reg: Reg,
        imm: i32,
    };

    fn imm_reg(code: u8, dst: Reg, src: anytype, off: i16) Insn {
        const imm_or_reg = if (@TypeOf(src) == Reg or @typeInfo(@TypeOf(src)) == .enum_literal)
            ImmOrReg{ .reg = @as(Reg, src) }
        else
            ImmOrReg{ .imm = src };

        const src_type: u8 = switch (imm_or_reg) {
            .imm => K,
            .reg => X,
        };

        return Insn{
            .code = code | src_type,
            .dst = @backingInt(dst),
            .src = switch (imm_or_reg) {
                .imm => 0,
                .reg => |r| @backingInt(r),
            },
            .off = off,
            .imm = switch (imm_or_reg) {
                .imm => |i| i,
                .reg => 0,
            },
        };
    }

    pub fn alu(comptime width: comptime_int, op: AluOp, dst: Reg, src: anytype) Insn {
        const width_bitfield = switch (width) {
            32 => ALU,
            64 => ALU64,
            else => @compileError("width must be 32 or 64"),
        };

        return imm_reg(width_bitfield | @backingInt(op), dst, src, 0);
    }

    pub fn mov(dst: Reg, src: anytype) Insn {
        return alu(64, .mov, dst, src);
    }

    pub fn add(dst: Reg, src: anytype) Insn {
        return alu(64, .add, dst, src);
    }

    pub fn sub(dst: Reg, src: anytype) Insn {
        return alu(64, .sub, dst, src);
    }

    pub fn mul(dst: Reg, src: anytype) Insn {
        return alu(64, .mul, dst, src);
    }

    pub fn div(dst: Reg, src: anytype) Insn {
        return alu(64, .div, dst, src);
    }

    pub fn alu_or(dst: Reg, src: anytype) Insn {
        return alu(64, .alu_or, dst, src);
    }

    pub fn alu_and(dst: Reg, src: anytype) Insn {
        return alu(64, .alu_and, dst, src);
    }

    pub fn lsh(dst: Reg, src: anytype) Insn {
        return alu(64, .lsh, dst, src);
    }

    pub fn rsh(dst: Reg, src: anytype) Insn {
        return alu(64, .rsh, dst, src);
    }

    pub fn neg(dst: Reg) Insn {
        return alu(64, .neg, dst, 0);
    }

    pub fn mod(dst: Reg, src: anytype) Insn {
        return alu(64, .mod, dst, src);
    }

    pub fn xor(dst: Reg, src: anytype) Insn {
        return alu(64, .xor, dst, src);
    }

    pub fn arsh(dst: Reg, src: anytype) Insn {
        return alu(64, .arsh, dst, src);
    }

    pub fn jmp(op: JmpOp, dst: Reg, src: anytype, off: i16) Insn {
        return imm_reg(JMP | @backingInt(op), dst, src, off);
    }

    pub fn ja(off: i16) Insn {
        return jmp(.ja, .r0, 0, off);
    }

    pub fn jeq(dst: Reg, src: anytype, off: i16) Insn {
        return jmp(.jeq, dst, src, off);
    }

    pub fn jgt(dst: Reg, src: anytype, off: i16) Insn {
        return jmp(.jgt, dst, src, off);
    }

    pub fn jge(dst: Reg, src: anytype, off: i16) Insn {
        return jmp(.jge, dst, src, off);
    }

    pub fn jlt(dst: Reg, src: anytype, off: i16) Insn {
        return jmp(.jlt, dst, src, off);
    }

    pub fn jle(dst: Reg, src: anytype, off: i16) Insn {
        return jmp(.jle, dst, src, off);
    }

    pub fn jset(dst: Reg, src: anytype, off: i16) Insn {
        return jmp(.jset, dst, src, off);
    }

    pub fn jne(dst: Reg, src: anytype, off: i16) Insn {
        return jmp(.jne, dst, src, off);
    }

    pub fn jsgt(dst: Reg, src: anytype, off: i16) Insn {
        return jmp(.jsgt, dst, src, off);
    }

    pub fn jsge(dst: Reg, src: anytype, off: i16) Insn {
        return jmp(.jsge, dst, src, off);
    }

    pub fn jslt(dst: Reg, src: anytype, off: i16) Insn {
        return jmp(.jslt, dst, src, off);
    }

    pub fn jsle(dst: Reg, src: anytype, off: i16) Insn {
        return jmp(.jsle, dst, src, off);
    }

    pub fn xadd(dst: Reg, src: Reg) Insn {
        return Insn{
            .code = STX | XADD | DW,
            .dst = @backingInt(dst),
            .src = @backingInt(src),
            .off = 0,
            .imm = 0,
        };
    }

    fn ld(mode: Mode, size: Size, dst: Reg, src: Reg, imm: i32) Insn {
        return Insn{
            .code = @backingInt(mode) | @backingInt(size) | LD,
            .dst = @backingInt(dst),
            .src = @backingInt(src),
            .off = 0,
            .imm = imm,
        };
    }

    pub fn ld_abs(size: Size, dst: Reg, src: Reg, imm: i32) Insn {
        return ld(.abs, size, dst, src, imm);
    }

    pub fn ld_ind(size: Size, dst: Reg, src: Reg, imm: i32) Insn {
        return ld(.ind, size, dst, src, imm);
    }

    pub fn ldx(size: Size, dst: Reg, src: Reg, off: i16) Insn {
        return Insn{
            .code = MEM | @backingInt(size) | LDX,
            .dst = @backingInt(dst),
            .src = @backingInt(src),
            .off = off,
            .imm = 0,
        };
    }

    fn ld_imm_impl1(dst: Reg, src: Reg, imm: u64) Insn {
        return Insn{
            .code = LD | DW | IMM,
            .dst = @backingInt(dst),
            .src = @backingInt(src),
            .off = 0,
            .imm = @as(i32, @bitCast(@as(u32, @truncate(imm)))),
        };
    }

    fn ld_imm_impl2(imm: u64) Insn {
        return Insn{
            .code = 0,
            .dst = 0,
            .src = 0,
            .off = 0,
            .imm = @as(i32, @bitCast(@as(u32, @truncate(imm >> 32)))),
        };
    }

    pub fn ld_dw1(dst: Reg, imm: u64) Insn {
        return ld_imm_impl1(dst, .r0, imm);
    }

    pub fn ld_dw2(imm: u64) Insn {
        return ld_imm_impl2(imm);
    }

    pub fn ld_map_fd1(dst: Reg, map_fd: fd_t) Insn {
        return ld_imm_impl1(dst, @as(Reg, @fromBackingInt(@intCast(PSEUDO_MAP_FD))), @as(u64, @intCast(map_fd)));
    }

    pub fn ld_map_fd2(map_fd: fd_t) Insn {
        return ld_imm_impl2(@as(u64, @intCast(map_fd)));
    }

    pub fn st(size: Size, dst: Reg, off: i16, imm: i32) Insn {
        return Insn{
            .code = MEM | @backingInt(size) | ST,
            .dst = @backingInt(dst),
            .src = 0,
            .off = off,
            .imm = imm,
        };
    }

    pub fn stx(size: Size, dst: Reg, off: i16, src: Reg) Insn {
        return Insn{
            .code = MEM | @backingInt(size) | STX,
            .dst = @backingInt(dst),
            .src = @backingInt(src),
            .off = off,
            .imm = 0,
        };
    }

    fn endian_swap(endian: std.builtin.Endian, comptime size: Size, dst: Reg) Insn {
        return Insn{
            .code = switch (endian) {
                .big => 0xdc,
                .little => 0xd4,
            },
            .dst = @backingInt(dst),
            .src = 0,
            .off = 0,
            .imm = switch (size) {
                .byte => @compileError("can't swap a single byte"),
                .half_word => 16,
                .word => 32,
                .double_word => 64,
            },
        };
    }

    pub fn le(comptime size: Size, dst: Reg) Insn {
        return endian_swap(.little, size, dst);
    }

    pub fn be(comptime size: Size, dst: Reg) Insn {
        return endian_swap(.big, size, dst);
    }

    pub fn call(helper: Helper) Insn {
        return Insn{
            .code = JMP | CALL,
            .dst = 0,
            .src = 0,
            .off = 0,
            .imm = @backingInt(helper),
        };
    }

    /// 退出 BPF 程序
    pub fn exit() Insn {
        return Insn{
            .code = JMP | EXIT,
            .dst = 0,
            .src = 0,
            .off = 0,
            .imm = 0,
        };
    }
};

test "insn bitsize" {
    try expectEqual(@bitSizeOf(Insn), 64);
}

fn expect_opcode(code: u8, insn: Insn) !void {
    try expectEqual(code, insn.code);
}

// 操作码取自 https://github.com/iovisor/bpf-docs/blob/master/eBPF.md
test "opcodes" {
    // 名称以 1 或 2 结尾的指令按顺序排列,用于
    // 加载 64 位立即数(imm 只有 32 位宽)

    // alu 指令
    try expect_opcode(0x07, Insn.add(.r1, 0));
    try expect_opcode(0x0f, Insn.add(.r1, .r2));
    try expect_opcode(0x17, Insn.sub(.r1, 0));
    try expect_opcode(0x1f, Insn.sub(.r1, .r2));
    try expect_opcode(0x27, Insn.mul(.r1, 0));
    try expect_opcode(0x2f, Insn.mul(.r1, .r2));
    try expect_opcode(0x37, Insn.div(.r1, 0));
    try expect_opcode(0x3f, Insn.div(.r1, .r2));
    try expect_opcode(0x47, Insn.alu_or(.r1, 0));
    try expect_opcode(0x4f, Insn.alu_or(.r1, .r2));
    try expect_opcode(0x57, Insn.alu_and(.r1, 0));
    try expect_opcode(0x5f, Insn.alu_and(.r1, .r2));
    try expect_opcode(0x67, Insn.lsh(.r1, 0));
    try expect_opcode(0x6f, Insn.lsh(.r1, .r2));
    try expect_opcode(0x77, Insn.rsh(.r1, 0));
    try expect_opcode(0x7f, Insn.rsh(.r1, .r2));
    try expect_opcode(0x87, Insn.neg(.r1));
    try expect_opcode(0x97, Insn.mod(.r1, 0));
    try expect_opcode(0x9f, Insn.mod(.r1, .r2));
    try expect_opcode(0xa7, Insn.xor(.r1, 0));
    try expect_opcode(0xaf, Insn.xor(.r1, .r2));
    try expect_opcode(0xb7, Insn.mov(.r1, 0));
    try expect_opcode(0xbf, Insn.mov(.r1, .r2));
    try expect_opcode(0xc7, Insn.arsh(.r1, 0));
    try expect_opcode(0xcf, Insn.arsh(.r1, .r2));

    // 原子指令:实际可能还有更多未记录的指令
    try expect_opcode(0xdb, Insn.xadd(.r1, .r2));

    // TODO: 字节交换指令
    try expect_opcode(0xd4, Insn.le(.half_word, .r1));
    try expectEqual(@as(i32, @intCast(16)), Insn.le(.half_word, .r1).imm);
    try expect_opcode(0xd4, Insn.le(.word, .r1));
    try expectEqual(@as(i32, @intCast(32)), Insn.le(.word, .r1).imm);
    try expect_opcode(0xd4, Insn.le(.double_word, .r1));
    try expectEqual(@as(i32, @intCast(64)), Insn.le(.double_word, .r1).imm);
    try expect_opcode(0xdc, Insn.be(.half_word, .r1));
    try expectEqual(@as(i32, @intCast(16)), Insn.be(.half_word, .r1).imm);
    try expect_opcode(0xdc, Insn.be(.word, .r1));
    try expectEqual(@as(i32, @intCast(32)), Insn.be(.word, .r1).imm);
    try expect_opcode(0xdc, Insn.be(.double_word, .r1));
    try expectEqual(@as(i32, @intCast(64)), Insn.be(.double_word, .r1).imm);

    // 内存指令
    try expect_opcode(0x18, Insn.ld_dw1(.r1, 0));
    try expect_opcode(0x00, Insn.ld_dw2(0));

    //   加载映射 fd
    try expect_opcode(0x18, Insn.ld_map_fd1(.r1, 0));
    try expectEqual(@as(u4, @intCast(PSEUDO_MAP_FD)), Insn.ld_map_fd1(.r1, 0).src);
    try expect_opcode(0x00, Insn.ld_map_fd2(0));

    try expect_opcode(0x38, Insn.ld_abs(.double_word, .r1, .r2, 0));
    try expect_opcode(0x20, Insn.ld_abs(.word, .r1, .r2, 0));
    try expect_opcode(0x28, Insn.ld_abs(.half_word, .r1, .r2, 0));
    try expect_opcode(0x30, Insn.ld_abs(.byte, .r1, .r2, 0));

    try expect_opcode(0x58, Insn.ld_ind(.double_word, .r1, .r2, 0));
    try expect_opcode(0x40, Insn.ld_ind(.word, .r1, .r2, 0));
    try expect_opcode(0x48, Insn.ld_ind(.half_word, .r1, .r2, 0));
    try expect_opcode(0x50, Insn.ld_ind(.byte, .r1, .r2, 0));

    try expect_opcode(0x79, Insn.ldx(.double_word, .r1, .r2, 0));
    try expect_opcode(0x61, Insn.ldx(.word, .r1, .r2, 0));
    try expect_opcode(0x69, Insn.ldx(.half_word, .r1, .r2, 0));
    try expect_opcode(0x71, Insn.ldx(.byte, .r1, .r2, 0));

    try expect_opcode(0x62, Insn.st(.word, .r1, 0, 0));
    try expect_opcode(0x6a, Insn.st(.half_word, .r1, 0, 0));
    try expect_opcode(0x72, Insn.st(.byte, .r1, 0, 0));

    try expect_opcode(0x63, Insn.stx(.word, .r1, 0, .r2));
    try expect_opcode(0x6b, Insn.stx(.half_word, .r1, 0, .r2));
    try expect_opcode(0x73, Insn.stx(.byte, .r1, 0, .r2));
    try expect_opcode(0x7b, Insn.stx(.double_word, .r1, 0, .r2));

    // 分支指令
    try expect_opcode(0x05, Insn.ja(0));
    try expect_opcode(0x15, Insn.jeq(.r1, 0, 0));
    try expect_opcode(0x1d, Insn.jeq(.r1, .r2, 0));
    try expect_opcode(0x25, Insn.jgt(.r1, 0, 0));
    try expect_opcode(0x2d, Insn.jgt(.r1, .r2, 0));
    try expect_opcode(0x35, Insn.jge(.r1, 0, 0));
    try expect_opcode(0x3d, Insn.jge(.r1, .r2, 0));
    try expect_opcode(0xa5, Insn.jlt(.r1, 0, 0));
    try expect_opcode(0xad, Insn.jlt(.r1, .r2, 0));
    try expect_opcode(0xb5, Insn.jle(.r1, 0, 0));
    try expect_opcode(0xbd, Insn.jle(.r1, .r2, 0));
    try expect_opcode(0x45, Insn.jset(.r1, 0, 0));
    try expect_opcode(0x4d, Insn.jset(.r1, .r2, 0));
    try expect_opcode(0x55, Insn.jne(.r1, 0, 0));
    try expect_opcode(0x5d, Insn.jne(.r1, .r2, 0));
    try expect_opcode(0x65, Insn.jsgt(.r1, 0, 0));
    try expect_opcode(0x6d, Insn.jsgt(.r1, .r2, 0));
    try expect_opcode(0x75, Insn.jsge(.r1, 0, 0));
    try expect_opcode(0x7d, Insn.jsge(.r1, .r2, 0));
    try expect_opcode(0xc5, Insn.jslt(.r1, 0, 0));
    try expect_opcode(0xcd, Insn.jslt(.r1, .r2, 0));
    try expect_opcode(0xd5, Insn.jsle(.r1, 0, 0));
    try expect_opcode(0xdd, Insn.jsle(.r1, .r2, 0));
    try expect_opcode(0x85, Insn.call(.unspec));
    try expect_opcode(0x95, Insn.exit());
}

pub const Cmd = enum(usize) {
    /// 创建映射,并返回引用该映射的文件描述符。
    /// 新文件描述符自动启用执行时关闭
    /// 标志。
    ///
    /// 使用 MapCreateAttr。
    map_create,

    /// 按键在指定映射中查找元素并返回其值。
    ///
    /// 使用 MapElemAttr
    map_lookup_elem,

    /// 在指定映射中创建或更新元素(键值对)。
    ///
    /// 使用 MapElemAttr
    map_update_elem,

    /// 按键查找并删除指定映射中的元素。
    ///
    /// 使用 MapElemAttr
    map_delete_elem,

    /// 按键在指定映射中查找元素,并返回下一个元素的键。
    ///
    map_get_next_key,

    /// 验证并加载 eBPF 程序,返回与该程序关联的
    /// 新文件描述符。新文件描述符会自动启用
    /// 执行时关闭标志。
    ///
    /// 使用 ProgLoadAttr。
    prog_load,

    /// 将映射或 eBPF 程序固定到最小 BPF 文件系统中的路径
    ///
    /// 使用 ObjAttr
    obj_pin,

    /// 获取固定到指定路径的 BPF 对象的文件描述符
    ///
    /// 使用 ObjAttr
    obj_get,

    /// 使用 ProgAttachAttr
    prog_attach,

    /// 使用 ProgAttachAttr
    prog_detach,

    /// 使用 TestRunAttr
    prog_test_run,

    /// 使用 GetIdAttr
    prog_get_next_id,

    /// 使用 GetIdAttr
    map_get_next_id,

    /// 使用 GetIdAttr
    prog_get_fd_by_id,

    /// 使用 GetIdAttr
    map_get_fd_by_id,

    /// 使用 InfoAttr
    obj_get_info_by_fd,

    /// 使用 QueryAttr
    prog_query,

    /// 使用 RawTracepointAttr
    raw_tracepoint_open,

    /// 使用 BtfLoadAttr
    btf_load,

    /// 使用 GetIdAttr
    btf_get_fd_by_id,

    /// 使用 TaskFdQueryAttr
    task_fd_query,

    /// 使用 MapElemAttr
    map_lookup_and_delete_elem,
    map_freeze,

    /// 使用 GetIdAttr
    btf_get_next_id,

    /// 使用 MapBatchAttr
    map_lookup_batch,

    /// 使用 MapBatchAttr
    map_lookup_and_delete_batch,

    /// 使用 MapBatchAttr
    map_update_batch,

    /// 使用 MapBatchAttr
    map_delete_batch,

    /// 使用 LinkCreateAttr
    link_create,

    /// 使用 LinkUpdateAttr
    link_update,

    /// 使用 GetIdAttr
    link_get_fd_by_id,

    /// 使用 GetIdAttr
    link_get_next_id,

    /// 使用 EnableStatsAttr
    enable_stats,

    /// 使用 IterCreateAttr
    iter_create,
    link_detach,
    _,
};

pub const MapType = enum(u32) {
    unspec,
    hash,
    array,
    prog_array,
    perf_event_array,
    percpu_hash,
    percpu_array,
    stack_trace,
    cgroup_array,
    lru_hash,
    lru_percpu_hash,
    lpm_trie,
    array_of_maps,
    hash_of_maps,
    devmap,
    sockmap,
    cpumap,
    xskmap,
    sockhash,
    cgroup_storage_deprecated,
    reuseport_sockarray,
    percpu_cgroup_storage,
    queue,
    stack,
    sk_storage,
    devmap_hash,
    struct_ops,

    /// perf_event_array 的有序、跨 CPU 共享版本,具有类似语义:
    ///     - 变长记录
    ///     - 非阻塞:已满时预留失败
    ///     - 支持内存映射,便于使用并提升速度
    ///     - 新数据通过 epoll 通知,也可忙轮询
    ///
    /// 环形缓冲区为 BPF 程序提供两组接口:
    ///     - ringbuf_output() 将其他位置的数据复制到环形缓冲区,类似 bpf_perf_event_output()。
    ///     - ringbuf_reserve()/ringbuf_commit()/ringbuf_discard() 将过程分为两步:先预留固定大小空间;成功后程序取得内存块指针,可以通过 commit() 提交或 discard() 丢弃。
    ///
    /// ringbuf_output() 会增加一次内存复制,但允许提交事先未知长度的记录,是替换 perf_event_output() 的简单方式。
    ///
    /// ringbuf_reserve() 避免额外复制,但要求预先知道内存大小。
    ///
    /// ringbuf_query() 用于查询映射属性,目前支持四项:
    ///     - BPF_RB_AVAIL_DATA:环形缓冲区未消费的数据量
    ///     - BPF_RB_RING_SIZE:环形缓冲区大小
    ///     - BPF_RB_CONS_POS/BPF_RB_PROD_POS:分别为消费者和生产者当前逻辑位置
    ///
    /// 键大小:0
    /// 值大小:0
    /// 最大条目数:环形缓冲区大小,必须是二的幂
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ///
    ringbuf,
    inode_storage,
    task_storage,
    bloom_filter,
    user_ringbuf,
    cgroup_storage,
    arena,

    _,
};

pub const ProgType = enum(u32) {
    unspec,

    /// 上下文类型:__sk_buff
    socket_filter,

    /// 上下文类型:bpf_user_pt_regs_t
    kprobe,

    /// 上下文类型:__sk_buff
    sched_cls,

    /// 上下文类型:__sk_buff
    sched_act,

    /// 上下文类型:u64
    tracepoint,

    /// 上下文类型:xdp_md
    xdp,

    /// 上下文类型:bpf_perf_event_data
    perf_event,

    /// 上下文类型:__sk_buff
    cgroup_skb,

    /// 上下文类型:bpf_sock
    cgroup_sock,

    /// 上下文类型:__sk_buff
    lwt_in,

    /// 上下文类型:__sk_buff
    lwt_out,

    /// 上下文类型:__sk_buff
    lwt_xmit,

    /// 上下文类型:bpf_sock_ops
    sock_ops,

    /// 上下文类型:__sk_buff
    sk_skb,

    /// 上下文类型:bpf_cgroup_dev_ctx
    cgroup_device,

    /// 上下文类型:sk_msg_md
    sk_msg,

    /// 上下文类型:bpf_raw_tracepoint_args
    raw_tracepoint,

    /// 上下文类型:bpf_sock_addr
    cgroup_sock_addr,

    /// 上下文类型:__sk_buff
    lwt_seg6local,

    /// 上下文类型:u32
    lirc_mode2,

    /// 上下文类型:sk_reuseport_md
    sk_reuseport,

    /// 上下文类型:__sk_buff
    flow_dissector,

    /// 上下文类型:bpf_sysctl
    cgroup_sysctl,

    /// 上下文类型:bpf_raw_tracepoint_args
    raw_tracepoint_writable,

    /// 上下文类型:bpf_sockopt
    cgroup_sockopt,

    /// 上下文类型:void *
    tracing,

    /// 上下文类型:void *
    struct_ops,

    /// 上下文类型:void *
    ext,

    /// 上下文类型:void *
    lsm,

    /// 上下文类型:bpf_sk_lookup
    sk_lookup,

    /// 上下文类型:void *
    syscall,

    /// 上下文类型:bpf_nf_ctx
    netfilter,

    _,
};

pub const AttachType = enum(u32) {
    cgroup_inet_ingress,
    cgroup_inet_egress,
    cgroup_inet_sock_create,
    cgroup_sock_ops,
    sk_skb_stream_parser,
    sk_skb_stream_verdict,
    cgroup_device,
    sk_msg_verdict,
    cgroup_inet4_bind,
    cgroup_inet6_bind,
    cgroup_inet4_connect,
    cgroup_inet6_connect,
    cgroup_inet4_post_bind,
    cgroup_inet6_post_bind,
    cgroup_udp4_sendmsg,
    cgroup_udp6_sendmsg,
    lirc_mode2,
    flow_dissector,
    cgroup_sysctl,
    cgroup_udp4_recvmsg,
    cgroup_udp6_recvmsg,
    cgroup_getsockopt,
    cgroup_setsockopt,
    trace_raw_tp,
    trace_fentry,
    trace_fexit,
    modify_return,
    lsm_mac,
    trace_iter,
    cgroup_inet4_getpeername,
    cgroup_inet6_getpeername,
    cgroup_inet4_getsockname,
    cgroup_inet6_getsockname,
    xdp_devmap,
    cgroup_inet_sock_release,
    xdp_cpumap,
    sk_lookup,
    xdp,
    sk_skb_verdict,
    sk_reuseport_select,
    sk_reuseport_select_or_migrate,
    perf_event,
    trace_kprobe_multi,
    lsm_cgroup,
    struct_ops,
    netfilter,
    tcx_ingress,
    tcx_egress,
    trace_uprobe_multi,
    cgroup_unix_connect,
    cgroup_unix_sendmsg,
    cgroup_unix_recvmsg,
    cgroup_unix_getpeername,
    cgroup_unix_getsockname,
    netkit_primary,
    netkit_peer,
    trace_kprobe_session,
    _,
};

const obj_name_len = 16;
/// Cmd.map_create 命令使用的结构体
pub const MapCreateAttr = extern struct {
    /// MapType 中的一种
    map_type: u32,

    /// 键的字节大小
    key_size: u32,

    /// 值的大小,单位为字节
    value_size: u32,

    /// 映射中的最大条目数
    max_entries: u32,

    /// 与 .map_create 相关的标志
    map_flags: u32,

    /// 指向内部映射的文件描述符
    inner_map_fd: fd_t,

    /// NUMA 节点(仅设置 MapCreateFlags.numa_node 时有效)。
    numa_node: u32,
    map_name: [obj_name_len]u8,

    /// 要在其上创建对象的网络设备接口索引
    map_ifindex: u32,

    /// 指向 BTF 类型数据的文件描述符
    btf_fd: fd_t,

    /// 键的 BTF type_id
    btf_key_type_id: u32,

    /// 值的 BTF type_id
    bpf_value_type_id: u32,

    /// 作为映射值存储的内核结构体的 BTF type_id。
    btf_vmlinux_value_type_id: u32,
};

/// Cmd.map_*_elem 命令使用的结构体
pub const MapElemAttr = extern struct {
    map_fd: fd_t,
    key: u64,
    result: extern union {
        value: u64,
        next_key: u64,
    },
    flags: u64,
};

/// Cmd.map_*_batch 命令使用的结构体
pub const MapBatchAttr = extern struct {
    /// 起始批次,为 NULL 时从开头开始
    in_batch: u64,

    /// 输出:下一起始批次
    out_batch: u64,
    keys: u64,
    values: u64,

    /// 输入/输出:
    /// 输入:键值元素数量。
    /// 输出:已填充元素数量。
    count: u32,
    map_fd: fd_t,
    elem_flags: u64,
    flags: u64,
};

/// Cmd.prog_load 命令使用的结构体
pub const ProgLoadAttr = extern struct {
    /// ProgType 中的一项
    prog_type: u32,
    insn_cnt: u32,
    insns: u64,
    license: u64,

    /// 验证器的详细程度
    log_level: u32,

    /// 用户缓冲区大小
    log_size: u32,

    /// 用户提供的缓冲区
    log_buf: u64,

    /// 未使用
    kern_version: u32,
    prog_flags: u32,
    prog_name: [obj_name_len]u8,

    /// 要准备的网络设备的 ifindex。
    prog_ifindex: u32,

    /// 某些程序类型必须在加载时知道预期附加类型,
    /// 以验证程序中特定于该附加类型的部分
    /// (上下文访问、允许的辅助函数等)。
    expected_attach_type: u32,

    /// 指向 BTF 类型数据的 fd
    prog_btf_fd: fd_t,

    /// 用户空间的 bpf_func_info 大小
    func_info_rec_size: u32,
    func_info: u64,

    /// bpf_func_info 记录的数量
    func_info_cnt: u32,

    /// 用户空间 bpf_line_info 的大小
    line_info_rec_size: u32,
    line_info: u64,

    /// bpf_line_info 记录数量
    line_info_cnt: u32,

    /// 要附加的内核态 BTF 类型标识符
    attact_btf_id: u32,

    /// 0 表示附加到 vmlinux
    attach_prog_id: u32,
};

/// Cmd.obj_* 命令使用的结构体
pub const ObjAttr = extern struct {
    pathname: u64,
    bpf_fd: fd_t,
    file_flags: u32,
};

/// Cmd.prog_attach/detach 命令使用的结构体。
pub const ProgAttachAttr = extern struct {
    /// 要附加到的容器对象
    target_fd: fd_t,

    /// 要附加的 eBPF 程序
    attach_bpf_fd: fd_t,

    attach_type: u32,
    attach_flags: u32,

    // TODO: BPF_F_REPLACE 标志
    /// 使用 .replace 时,要替换的先前附加 eBPF 程序
    replace_bpf_fd: fd_t,
};

/// Cmd.prog_test_run 命令使用的结构体
pub const TestRunAttr = extern struct {
    prog_fd: fd_t,
    retval: u32,

    /// 输入:data_in 的长度
    data_size_in: u32,

    /// 输入/输出:data_out 的长度。若 data_out 太小,则返回 ENOSPC。
    data_size_out: u32,
    data_in: u64,
    data_out: u64,
    repeat: u32,
    duration: u32,

    /// 输入:ctx_in 的长度
    ctx_size_in: u32,

    /// 输入/输出:ctx_out 的长度。ctx_out 过小时返回 ENOSPC。
    ctx_size_out: u32,
    ctx_in: u64,
    ctx_out: u64,
};

/// Cmd.*_get_*_id 命令使用的结构体
pub const GetIdAttr = extern struct {
    id: extern union {
        start_id: u32,
        prog_id: u32,
        map_id: u32,
        btf_id: u32,
        link_id: u32,
    },
    next_id: u32,
    open_flags: u32,
};

/// Cmd.obj_get_info_by_fd 命令使用的结构体
pub const InfoAttr = extern struct {
    bpf_fd: fd_t,
    info_len: u32,
    info: u64,
};

/// Cmd.prog_query 命令使用的结构体
pub const QueryAttr = extern struct {
    /// 要查询的容器对象
    target_fd: fd_t,
    attach_type: u32,
    query_flags: u32,
    attach_flags: u32,
    prog_ids: u64,
    prog_cnt: u32,
};

/// Cmd.raw_tracepoint_open 命令使用的结构体
pub const RawTracepointAttr = extern struct {
    name: u64,
    prog_fd: fd_t,
};

/// Cmd.btf_load 命令使用的结构体
pub const BtfLoadAttr = extern struct {
    btf: u64,
    btf_log_buf: u64,
    btf_size: u32,
    btf_log_size: u32,
    btf_log_level: u32,
};

/// Cmd.task_fd_query 使用的结构体
pub const TaskFdQueryAttr = extern struct {
    /// 输入:pid
    pid: pid_t,

    /// 输入:fd
    fd: fd_t,

    /// 输入:flags
    flags: u32,

    /// 输入/输出:缓冲区长度
    buf_len: u32,

    /// 输入/输出:
    ///     跟踪点的 tp_name
    ///     kprobe 的 symbol
    ///     uprobe 的 filename
    buf: u64,

    /// 输出:prod_id
    prog_id: u32,

    /// 输出:BPF_FD_TYPE
    fd_type: u32,

    /// 输出:probe_offset
    probe_offset: u64,

    /// 输出:probe_addr
    probe_addr: u64,
};

/// Cmd.link_create 命令使用的结构体
pub const LinkCreateAttr = extern struct {
    /// 要附加的 eBPF 程序
    prog_fd: fd_t,

    /// 要附加到的对象
    target_fd: fd_t,
    attach_type: u32,

    /// 额外标志
    flags: u32,
};

/// Cmd.link_update 命令使用的结构体
pub const LinkUpdateAttr = extern struct {
    link_fd: fd_t,

    /// 用于更新链接的新程序
    new_prog_fd: fd_t,

    /// 额外标志
    flags: u32,

    /// 预期链接的程序文件描述符,
    /// 仅在 flags 中设置 BPF_F_REPLACE 时指定。
    old_prog_fd: fd_t,
};

/// Cmd.enable_stats 命令使用的结构体
pub const EnableStatsAttr = extern struct {
    type: u32,
};

/// Cmd.iter_create 命令使用的结构体
pub const IterCreateAttr = extern struct {
    link_fd: fd_t,
    flags: u32,
};

/// 传给 bpf() 系统调用的大型结构体。
pub const Attr = extern union {
    map_create: MapCreateAttr,
    map_elem: MapElemAttr,
    map_batch: MapBatchAttr,
    prog_load: ProgLoadAttr,
    obj: ObjAttr,
    prog_attach: ProgAttachAttr,
    test_run: TestRunAttr,
    get_id: GetIdAttr,
    info: InfoAttr,
    query: QueryAttr,
    raw_tracepoint: RawTracepointAttr,
    btf_load: BtfLoadAttr,
    task_fd_query: TaskFdQueryAttr,
    link_create: LinkCreateAttr,
    link_update: LinkUpdateAttr,
    enable_stats: EnableStatsAttr,
    iter_create: IterCreateAttr,
};

pub const Log = struct {
    level: u32,
    buf: []u8,
};

pub fn map_create(map_type: MapType, key_size: u32, value_size: u32, max_entries: u32) !fd_t {
    var attr = Attr{
        .map_create = std.mem.zeroes(MapCreateAttr),
    };

    attr.map_create.map_type = @backingInt(map_type);
    attr.map_create.key_size = key_size;
    attr.map_create.value_size = value_size;
    attr.map_create.max_entries = max_entries;

    const rc = linux.bpf(.map_create, &attr, @sizeOf(MapCreateAttr));
    switch (errno(rc)) {
        .SUCCESS => return @as(fd_t, @intCast(rc)),
        .INVAL => return error.MapTypeOrAttrInvalid,
        .NOMEM => return error.SystemResources,
        .PERM => return error.PermissionDenied,
        else => |err| return unexpectedErrno(err),
    }
}

test "map_create" {
    const map = try map_create(.hash, 4, 4, 32);
    defer _ = std.os.linux.close(map);
}

pub fn map_lookup_elem(fd: fd_t, key: []const u8, value: []u8) !void {
    var attr = Attr{
        .map_elem = std.mem.zeroes(MapElemAttr),
    };

    attr.map_elem.map_fd = fd;
    attr.map_elem.key = @intFromPtr(key.ptr);
    attr.map_elem.result.value = @intFromPtr(value.ptr);

    const rc = linux.bpf(.map_lookup_elem, &attr, @sizeOf(MapElemAttr));
    switch (errno(rc)) {
        .SUCCESS => return,
        .BADF => return error.BadFd,
        .FAULT => unreachable,
        .INVAL => return error.FieldInAttrNeedsZeroing,
        .NOENT => return error.NotFound,
        .PERM => return error.PermissionDenied,
        else => |err| return unexpectedErrno(err),
    }
}

pub fn map_update_elem(fd: fd_t, key: []const u8, value: []const u8, flags: u64) !void {
    var attr = Attr{
        .map_elem = std.mem.zeroes(MapElemAttr),
    };

    attr.map_elem.map_fd = fd;
    attr.map_elem.key = @intFromPtr(key.ptr);
    attr.map_elem.result = .{ .value = @intFromPtr(value.ptr) };
    attr.map_elem.flags = flags;

    const rc = linux.bpf(.map_update_elem, &attr, @sizeOf(MapElemAttr));
    switch (errno(rc)) {
        .SUCCESS => return,
        .@"2BIG" => return error.ReachedMaxEntries,
        .BADF => return error.BadFd,
        .FAULT => unreachable,
        .INVAL => return error.FieldInAttrNeedsZeroing,
        .NOMEM => return error.SystemResources,
        .PERM => return error.PermissionDenied,
        else => |err| return unexpectedErrno(err),
    }
}

pub fn map_delete_elem(fd: fd_t, key: []const u8) !void {
    var attr = Attr{
        .map_elem = std.mem.zeroes(MapElemAttr),
    };

    attr.map_elem.map_fd = fd;
    attr.map_elem.key = @intFromPtr(key.ptr);

    const rc = linux.bpf(.map_delete_elem, &attr, @sizeOf(MapElemAttr));
    switch (errno(rc)) {
        .SUCCESS => return,
        .BADF => return error.BadFd,
        .FAULT => unreachable,
        .INVAL => return error.FieldInAttrNeedsZeroing,
        .NOENT => return error.NotFound,
        .PERM => return error.PermissionDenied,
        else => |err| return unexpectedErrno(err),
    }
}

pub fn map_get_next_key(fd: fd_t, key: []const u8, next_key: []u8) !bool {
    var attr = Attr{
        .map_elem = std.mem.zeroes(MapElemAttr),
    };

    attr.map_elem.map_fd = fd;
    attr.map_elem.key = @intFromPtr(key.ptr);
    attr.map_elem.result.next_key = @intFromPtr(next_key.ptr);

    const rc = linux.bpf(.map_get_next_key, &attr, @sizeOf(MapElemAttr));
    switch (errno(rc)) {
        .SUCCESS => return true,
        .BADF => return error.BadFd,
        .FAULT => unreachable,
        .INVAL => return error.FieldInAttrNeedsZeroing,
        .NOENT => return false,
        .PERM => return error.PermissionDenied,
        else => |err| return unexpectedErrno(err),
    }
}

test "map lookup, update, and delete" {
    const key_size = 4;
    const value_size = 4;
    const map = try map_create(.hash, key_size, value_size, 1);
    defer _ = std.os.linux.close(map);

    const key = std.mem.zeroes([key_size]u8);
    var value = std.mem.zeroes([value_size]u8);

    // 查找不存在的值时失败
    try expectError(error.NotFound, map_lookup_elem(map, &key, &value));

    // 成功更新并查找元素
    try map_update_elem(map, &key, &value, 0);
    try map_lookup_elem(map, &key, &value);

    // 插入超过最大条目数时失败
    const second_key = [key_size]u8{ 0, 0, 0, 1 };
    try expectError(error.ReachedMaxEntries, map_update_elem(map, &second_key, &value, 0));

    // 成功遍历映射中的所有键
    var lookup_key = [_]u8{ 1, 0, 0, 0 };
    var next_key = [_]u8{ 2, 3, 4, 5 }; // 无效残留值
    const status = try map_get_next_key(map, &lookup_key, &next_key);
    try expectEqual(status, true);
    try expectEqual(next_key, key);
    lookup_key = next_key;
    const status2 = try map_get_next_key(map, &lookup_key, &next_key);
    try expectEqual(status2, false);

    // 成功删除现有元素
    try map_delete_elem(map, &key);
    try expectError(error.NotFound, map_lookup_elem(map, &key, &value));

    // 删除不存在的元素时失败
    try expectError(error.NotFound, map_delete_elem(map, &key));
}

pub fn prog_load(
    prog_type: ProgType,
    insns: []const Insn,
    log: ?*Log,
    license: []const u8,
    kern_version: u32,
    flags: u32,
) !fd_t {
    var attr = Attr{
        .prog_load = std.mem.zeroes(ProgLoadAttr),
    };

    attr.prog_load.prog_type = @backingInt(prog_type);
    attr.prog_load.insns = @intFromPtr(insns.ptr);
    attr.prog_load.insn_cnt = @as(u32, @intCast(insns.len));
    attr.prog_load.license = @intFromPtr(license.ptr);
    attr.prog_load.kern_version = kern_version;
    attr.prog_load.prog_flags = flags;

    if (log) |l| {
        attr.prog_load.log_buf = @intFromPtr(l.buf.ptr);
        attr.prog_load.log_size = @as(u32, @intCast(l.buf.len));
        attr.prog_load.log_level = l.level;
    }

    const rc = linux.bpf(.prog_load, &attr, @sizeOf(ProgLoadAttr));
    return switch (errno(rc)) {
        .SUCCESS => @as(fd_t, @intCast(rc)),
        .ACCES => error.UnsafeProgram,
        .FAULT => unreachable,
        .INVAL => error.InvalidProgram,
        .PERM => error.PermissionDenied,
        else => |err| unexpectedErrno(err),
    };
}

test "prog_load" {
    // 此处应失败,因为退出前未设置 r0
    const bad_prog = [_]Insn{
        Insn.exit(),
    };

    const good_prog = [_]Insn{
        Insn.mov(.r0, 0),
        Insn.exit(),
    };

    const prog = try prog_load(.socket_filter, &good_prog, null, "MIT", 0, 0);
    defer _ = std.os.linux.close(prog);

    try expectError(error.UnsafeProgram, prog_load(.socket_filter, &bad_prog, null, "MIT", 0, 0));
}