Core:
- Remove socket skb caches
- Add a SO_RESERVE_MEM socket op to forward allocate buffer space
and avoid memory accounting overhead on each message sent
- Introduce managed neighbor entries - added by control plane and
resolved by the kernel for use in acceleration paths (BPF / XDP
right now, HW offload users will benefit as well)
- Make neighbor eviction on link down controllable by userspace
to work around WiFi networks with bad roaming implementations
- vrf: Rework interaction with netfilter/conntrack
- fq_codel: implement L4S style ce_threshold_ect1 marking
- sch: Eliminate unnecessary RCU waits in mini_qdisc_pair_swap()
BPF:
- Add support for new btf kind BTF_KIND_TAG, arbitrary type tagging
as implemented in LLVM14
- Introduce bpf_get_branch_snapshot() to capture Last Branch Records
- Implement variadic trace_printk helper
- Add a new Bloomfilter map type
- Track <8-byte scalar spill and refill
- Access hw timestamp through BPF's __sk_buff
- Disallow unprivileged BPF by default
- Document BPF licensing
Netfilter:
- Introduce egress hook for looking at raw outgoing packets
- Allow matching on and modifying inner headers / payload data
- Add NFT_META_IFTYPE to match on the interface type either from
ingress or egress
Protocols:
- Multi-Path TCP:
- increase default max additional subflows to 2
- rework forward memory allocation
- add getsockopts: MPTCP_INFO, MPTCP_TCPINFO, MPTCP_SUBFLOW_ADDRS
- MCTP flow support allowing lower layer drivers to configure msg
muxing as needed
- Automatic Multicast Tunneling (AMT) driver based on RFC7450
- HSR support the redbox supervision frames (IEC-62439-3:2018)
- Support for the ip6ip6 encapsulation of IOAM
- Netlink interface for CAN-FD's Transmitter Delay Compensation
- Support SMC-Rv2 eliminating the current same-subnet restriction,
by exploiting the UDP encapsulation feature of RoCE adapters
- TLS: add SM4 GCM/CCM crypto support
- Bluetooth: initial support for link quality and audio/codec
offload
Driver APIs:
- Add a batched interface for RX buffer allocation in AF_XDP
buffer pool
- ethtool: Add ability to control transceiver modules' power mode
- phy: Introduce supported interfaces bitmap to express MAC
capabilities and simplify PHY code
- Drop rtnl_lock from DSA .port_fdb_{add,del} callbacks
New drivers:
- WiFi driver for Realtek 8852AE 802.11ax devices (rtw89)
- Ethernet driver for ASIX AX88796C SPI device (x88796c)
Drivers:
- Broadcom PHYs
- support 72165, 7712 16nm PHYs
- support IDDQ-SR for additional power savings
- PHY support for QCA8081, QCA9561 PHYs
- NXP DPAA2: support for IRQ coalescing
- NXP Ethernet (enetc): support for software TCP segmentation
- Renesas Ethernet (ravb) - support DMAC and EMAC blocks of
Gigabit-capable IP found on RZ/G2L SoC
- Intel 100G Ethernet
- support for eswitch offload of TC/OvS flow API, including
offload of GRE, VxLAN, Geneve tunneling
- support application device queues - ability to assign Rx and Tx
queues to application threads
- PTP and PPS (pulse-per-second) extensions
- Broadcom Ethernet (bnxt)
- devlink health reporting and device reload extensions
- Mellanox Ethernet (mlx5)
- offload macvlan interfaces
- support HW offload of TC rules involving OVS internal ports
- support HW-GRO and header/data split
- support application device queues
- Marvell OcteonTx2:
- add XDP support for PF
- add PTP support for VF
- Qualcomm Ethernet switch (qca8k): support for QCA8328
- Realtek Ethernet DSA switch (rtl8366rb)
- support bridge offload
- support STP, fast aging, disabling address learning
- support for Realtek RTL8365MB-VC, a 4+1 port 10M/100M/1GE switch
- Mellanox Ethernet/IB switch (mlxsw)
- multi-level qdisc hierarchy offload (e.g. RED, prio and shaping)
- offload root TBF qdisc as port shaper
- support multiple routing interface MAC address prefixes
- support for IP-in-IP with IPv6 underlay
- MediaTek WiFi (mt76)
- mt7921 - ASPM, 6GHz, SDIO and testmode support
- mt7915 - LED and TWT support
- Qualcomm WiFi (ath11k)
- include channel rx and tx time in survey dump statistics
- support for 80P80 and 160 MHz bandwidths
- support channel 2 in 6 GHz band
- spectral scan support for QCN9074
- support for rx decapsulation offload (data frames in 802.3
format)
- Qualcomm phone SoC WiFi (wcn36xx)
- enable Idle Mode Power Save (IMPS) to reduce power consumption
during idle
- Bluetooth driver support for MediaTek MT7922 and MT7921
- Enable support for AOSP Bluetooth extension in Qualcomm WCN399x
and Realtek 8822C/8852A
- Microsoft vNIC driver (mana)
- support hibernation and kexec
- Google vNIC driver (gve)
- support for jumbo frames
- implement Rx page reuse
Refactor:
- Make all writes to netdev->dev_addr go thru helpers, so that we
can add this address to the address rbtree and handle the updates
- Various TCP cleanups and optimizations including improvements
to CPU cache use
- Simplify the gnet_stats, Qdisc stats' handling and remove
qdisc->running sequence counter
- Driver changes and API updates to address devlink locking
deficiencies
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
-----BEGIN PGP SIGNATURE-----
iQIzBAABCAAdFiEE6jPA+I1ugmIBA4hXMUZtbf5SIrsFAmGAzX4ACgkQMUZtbf5S
IrvW3g//Q0ZLrOuHK9pZ8sCXMMhDj8qL6ajm0otMddHWA/+1UglwVBKFhsajfxOf
wJ/5LZis+XKLpLqKTU5chKVfn39HuDGe/D3l+egi01Gv5BW0+XzEhagfyR5tJX5z
wsGG5CXO/we/laVSzRiFtwwVEKHKN20YC+tIQwYOYP5Wy3q4G7qDsFhT7GqgsGCS
n74QUEAIB5Tz0ODWFqLtbsySzIurXrskibwt5T9bvAAlPw/lCU68mmG+NVJ7VddO
lBbNkLMOo8yW9Ci20H09SrYd4jZTmMARo9tsFO1tAvAMk7qpn0Wd8pnOYTjFFoMD
+qjiFSVMh7E0JGb8Y7NCvwaB99suAK5rfGP68Xwe62DfP7vYWEx4pZGxBP19F4ld
6Kn1ME33BX9rUF9tBecf0bdKfJUwB2Q2Xou/b9laG04bwiqsc9iG5FQq1C46lnLZ
QdzNiS1My4dJMczkWt66HF3Kx30ibwHfvKMIHjf4PqkzEatkv6Y6SBZ57KXL+Lde
0BQSFhbf0tm2Gf55etzrczLElI3uqHSFWUNZZ2Bt6WmzO1e6tpV9nAtRWF4C/dFg
QDpLJtOOOY65uq+qz09zoPfv2lem868SrCAuFrVn99bEpYjx/CGNFDeEI02l6jyr
84eUxd364UcbIk3fc+eTGdXHLQNVk30G0AHVBBxaWNIidwfqXeE=
=srde
-----END PGP SIGNATURE-----
Merge tag 'net-next-for-5.16' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next
Pull networking updates from Jakub Kicinski:
"Core:
- Remove socket skb caches
- Add a SO_RESERVE_MEM socket op to forward allocate buffer space and
avoid memory accounting overhead on each message sent
- Introduce managed neighbor entries - added by control plane and
resolved by the kernel for use in acceleration paths (BPF / XDP
right now, HW offload users will benefit as well)
- Make neighbor eviction on link down controllable by userspace to
work around WiFi networks with bad roaming implementations
- vrf: Rework interaction with netfilter/conntrack
- fq_codel: implement L4S style ce_threshold_ect1 marking
- sch: Eliminate unnecessary RCU waits in mini_qdisc_pair_swap()
BPF:
- Add support for new btf kind BTF_KIND_TAG, arbitrary type tagging
as implemented in LLVM14
- Introduce bpf_get_branch_snapshot() to capture Last Branch Records
- Implement variadic trace_printk helper
- Add a new Bloomfilter map type
- Track <8-byte scalar spill and refill
- Access hw timestamp through BPF's __sk_buff
- Disallow unprivileged BPF by default
- Document BPF licensing
Netfilter:
- Introduce egress hook for looking at raw outgoing packets
- Allow matching on and modifying inner headers / payload data
- Add NFT_META_IFTYPE to match on the interface type either from
ingress or egress
Protocols:
- Multi-Path TCP:
- increase default max additional subflows to 2
- rework forward memory allocation
- add getsockopts: MPTCP_INFO, MPTCP_TCPINFO, MPTCP_SUBFLOW_ADDRS
- MCTP flow support allowing lower layer drivers to configure msg
muxing as needed
- Automatic Multicast Tunneling (AMT) driver based on RFC7450
- HSR support the redbox supervision frames (IEC-62439-3:2018)
- Support for the ip6ip6 encapsulation of IOAM
- Netlink interface for CAN-FD's Transmitter Delay Compensation
- Support SMC-Rv2 eliminating the current same-subnet restriction, by
exploiting the UDP encapsulation feature of RoCE adapters
- TLS: add SM4 GCM/CCM crypto support
- Bluetooth: initial support for link quality and audio/codec offload
Driver APIs:
- Add a batched interface for RX buffer allocation in AF_XDP buffer
pool
- ethtool: Add ability to control transceiver modules' power mode
- phy: Introduce supported interfaces bitmap to express MAC
capabilities and simplify PHY code
- Drop rtnl_lock from DSA .port_fdb_{add,del} callbacks
New drivers:
- WiFi driver for Realtek 8852AE 802.11ax devices (rtw89)
- Ethernet driver for ASIX AX88796C SPI device (x88796c)
Drivers:
- Broadcom PHYs
- support 72165, 7712 16nm PHYs
- support IDDQ-SR for additional power savings
- PHY support for QCA8081, QCA9561 PHYs
- NXP DPAA2: support for IRQ coalescing
- NXP Ethernet (enetc): support for software TCP segmentation
- Renesas Ethernet (ravb) - support DMAC and EMAC blocks of
Gigabit-capable IP found on RZ/G2L SoC
- Intel 100G Ethernet
- support for eswitch offload of TC/OvS flow API, including
offload of GRE, VxLAN, Geneve tunneling
- support application device queues - ability to assign Rx and Tx
queues to application threads
- PTP and PPS (pulse-per-second) extensions
- Broadcom Ethernet (bnxt)
- devlink health reporting and device reload extensions
- Mellanox Ethernet (mlx5)
- offload macvlan interfaces
- support HW offload of TC rules involving OVS internal ports
- support HW-GRO and header/data split
- support application device queues
- Marvell OcteonTx2:
- add XDP support for PF
- add PTP support for VF
- Qualcomm Ethernet switch (qca8k): support for QCA8328
- Realtek Ethernet DSA switch (rtl8366rb)
- support bridge offload
- support STP, fast aging, disabling address learning
- support for Realtek RTL8365MB-VC, a 4+1 port 10M/100M/1GE switch
- Mellanox Ethernet/IB switch (mlxsw)
- multi-level qdisc hierarchy offload (e.g. RED, prio and shaping)
- offload root TBF qdisc as port shaper
- support multiple routing interface MAC address prefixes
- support for IP-in-IP with IPv6 underlay
- MediaTek WiFi (mt76)
- mt7921 - ASPM, 6GHz, SDIO and testmode support
- mt7915 - LED and TWT support
- Qualcomm WiFi (ath11k)
- include channel rx and tx time in survey dump statistics
- support for 80P80 and 160 MHz bandwidths
- support channel 2 in 6 GHz band
- spectral scan support for QCN9074
- support for rx decapsulation offload (data frames in 802.3
format)
- Qualcomm phone SoC WiFi (wcn36xx)
- enable Idle Mode Power Save (IMPS) to reduce power consumption
during idle
- Bluetooth driver support for MediaTek MT7922 and MT7921
- Enable support for AOSP Bluetooth extension in Qualcomm WCN399x and
Realtek 8822C/8852A
- Microsoft vNIC driver (mana)
- support hibernation and kexec
- Google vNIC driver (gve)
- support for jumbo frames
- implement Rx page reuse
Refactor:
- Make all writes to netdev->dev_addr go thru helpers, so that we can
add this address to the address rbtree and handle the updates
- Various TCP cleanups and optimizations including improvements to
CPU cache use
- Simplify the gnet_stats, Qdisc stats' handling and remove
qdisc->running sequence counter
- Driver changes and API updates to address devlink locking
deficiencies"
* tag 'net-next-for-5.16' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next: (2122 commits)
Revert "net: avoid double accounting for pure zerocopy skbs"
selftests: net: add arp_ndisc_evict_nocarrier
net: ndisc: introduce ndisc_evict_nocarrier sysctl parameter
net: arp: introduce arp_evict_nocarrier sysctl parameter
libbpf: Deprecate AF_XDP support
kbuild: Unify options for BTF generation for vmlinux and modules
selftests/bpf: Add a testcase for 64-bit bounds propagation issue.
bpf: Fix propagation of signed bounds from 64-bit min/max into 32-bit.
bpf: Fix propagation of bounds from 64-bit min/max into 32-bit and var_off.
net: vmxnet3: remove multiple false checks in vmxnet3_ethtool.c
net: avoid double accounting for pure zerocopy skbs
tcp: rename sk_wmem_free_skb
netdevsim: fix uninit value in nsim_drv_configure_vfs()
selftests/bpf: Fix also no-alu32 strobemeta selftest
bpf: Add missing map_delete_elem method to bloom filter map
selftests/bpf: Add bloom map success test for userspace calls
bpf: Add alignment padding for "map_extra" + consolidate holes
bpf: Bloom filter map naming fixups
selftests/bpf: Add test cases for struct_ops prog
bpf: Add dummy BPF STRUCT_OPS for test purpose
...
This commit is contained in:
Linus Torvalds
commit
fc02cb2b37
2296 changed files with 209495 additions and 44392 deletions
5
tools/testing/selftests/bpf/.gitignore
vendored
5
tools/testing/selftests/bpf/.gitignore
vendored
|
|
@ -9,8 +9,9 @@ test_tag
|
|||
FEATURE-DUMP.libbpf
|
||||
fixdep
|
||||
test_dev_cgroup
|
||||
/test_progs*
|
||||
!test_progs.h
|
||||
/test_progs
|
||||
/test_progs-no_alu32
|
||||
/test_progs-bpf_gcc
|
||||
test_verifier_log
|
||||
feature
|
||||
test_sock
|
||||
|
|
|
|||
|
|
@ -122,12 +122,15 @@ BPFOBJ := $(BUILD_DIR)/libbpf/libbpf.a
|
|||
ifneq ($(CROSS_COMPILE),)
|
||||
HOST_BUILD_DIR := $(BUILD_DIR)/host
|
||||
HOST_SCRATCH_DIR := $(OUTPUT)/host-tools
|
||||
HOST_INCLUDE_DIR := $(HOST_SCRATCH_DIR)/include
|
||||
else
|
||||
HOST_BUILD_DIR := $(BUILD_DIR)
|
||||
HOST_SCRATCH_DIR := $(SCRATCH_DIR)
|
||||
HOST_INCLUDE_DIR := $(INCLUDE_DIR)
|
||||
endif
|
||||
HOST_BPFOBJ := $(HOST_BUILD_DIR)/libbpf/libbpf.a
|
||||
RESOLVE_BTFIDS := $(HOST_BUILD_DIR)/resolve_btfids/resolve_btfids
|
||||
RUNQSLOWER_OUTPUT := $(BUILD_DIR)/runqslower/
|
||||
|
||||
VMLINUX_BTF_PATHS ?= $(if $(O),$(O)/vmlinux) \
|
||||
$(if $(KBUILD_OUTPUT),$(KBUILD_OUTPUT)/vmlinux) \
|
||||
|
|
@ -152,7 +155,7 @@ $(notdir $(TEST_GEN_PROGS) \
|
|||
# sort removes libbpf duplicates when not cross-building
|
||||
MAKE_DIRS := $(sort $(BUILD_DIR)/libbpf $(HOST_BUILD_DIR)/libbpf \
|
||||
$(HOST_BUILD_DIR)/bpftool $(HOST_BUILD_DIR)/resolve_btfids \
|
||||
$(INCLUDE_DIR))
|
||||
$(RUNQSLOWER_OUTPUT) $(INCLUDE_DIR))
|
||||
$(MAKE_DIRS):
|
||||
$(call msg,MKDIR,,$@)
|
||||
$(Q)mkdir -p $@
|
||||
|
|
@ -181,11 +184,13 @@ $(OUTPUT)/test_stub.o: test_stub.c $(BPFOBJ)
|
|||
|
||||
DEFAULT_BPFTOOL := $(HOST_SCRATCH_DIR)/sbin/bpftool
|
||||
|
||||
$(OUTPUT)/runqslower: $(BPFOBJ) | $(DEFAULT_BPFTOOL)
|
||||
$(Q)$(MAKE) $(submake_extras) -C $(TOOLSDIR)/bpf/runqslower \
|
||||
OUTPUT=$(SCRATCH_DIR)/ VMLINUX_BTF=$(VMLINUX_BTF) \
|
||||
BPFOBJ=$(BPFOBJ) BPF_INCLUDE=$(INCLUDE_DIR) && \
|
||||
cp $(SCRATCH_DIR)/runqslower $@
|
||||
$(OUTPUT)/runqslower: $(BPFOBJ) | $(DEFAULT_BPFTOOL) $(RUNQSLOWER_OUTPUT)
|
||||
$(Q)$(MAKE) $(submake_extras) -C $(TOOLSDIR)/bpf/runqslower \
|
||||
OUTPUT=$(RUNQSLOWER_OUTPUT) VMLINUX_BTF=$(VMLINUX_BTF) \
|
||||
BPFTOOL_OUTPUT=$(BUILD_DIR)/bpftool/ \
|
||||
BPFOBJ_OUTPUT=$(BUILD_DIR)/libbpf \
|
||||
BPFOBJ=$(BPFOBJ) BPF_INCLUDE=$(INCLUDE_DIR) && \
|
||||
cp $(RUNQSLOWER_OUTPUT)runqslower $@
|
||||
|
||||
TEST_GEN_PROGS_EXTENDED += $(DEFAULT_BPFTOOL)
|
||||
|
||||
|
|
@ -209,7 +214,9 @@ $(DEFAULT_BPFTOOL): $(wildcard $(BPFTOOLDIR)/*.[ch] $(BPFTOOLDIR)/Makefile) \
|
|||
CC=$(HOSTCC) LD=$(HOSTLD) \
|
||||
EXTRA_CFLAGS='-g -O0' \
|
||||
OUTPUT=$(HOST_BUILD_DIR)/bpftool/ \
|
||||
prefix= DESTDIR=$(HOST_SCRATCH_DIR)/ install
|
||||
LIBBPF_OUTPUT=$(HOST_BUILD_DIR)/libbpf/ \
|
||||
LIBBPF_DESTDIR=$(HOST_SCRATCH_DIR)/ \
|
||||
prefix= DESTDIR=$(HOST_SCRATCH_DIR)/ install-bin
|
||||
|
||||
all: docs
|
||||
|
||||
|
|
@ -225,7 +232,7 @@ docs-clean:
|
|||
|
||||
$(BPFOBJ): $(wildcard $(BPFDIR)/*.[ch] $(BPFDIR)/Makefile) \
|
||||
../../../include/uapi/linux/bpf.h \
|
||||
| $(INCLUDE_DIR) $(BUILD_DIR)/libbpf
|
||||
| $(BUILD_DIR)/libbpf
|
||||
$(Q)$(MAKE) $(submake_extras) -C $(BPFDIR) OUTPUT=$(BUILD_DIR)/libbpf/ \
|
||||
EXTRA_CFLAGS='-g -O0' \
|
||||
DESTDIR=$(SCRATCH_DIR) prefix= all install_headers
|
||||
|
|
@ -233,7 +240,7 @@ $(BPFOBJ): $(wildcard $(BPFDIR)/*.[ch] $(BPFDIR)/Makefile) \
|
|||
ifneq ($(BPFOBJ),$(HOST_BPFOBJ))
|
||||
$(HOST_BPFOBJ): $(wildcard $(BPFDIR)/*.[ch] $(BPFDIR)/Makefile) \
|
||||
../../../include/uapi/linux/bpf.h \
|
||||
| $(INCLUDE_DIR) $(HOST_BUILD_DIR)/libbpf
|
||||
| $(HOST_BUILD_DIR)/libbpf
|
||||
$(Q)$(MAKE) $(submake_extras) -C $(BPFDIR) \
|
||||
EXTRA_CFLAGS='-g -O0' \
|
||||
OUTPUT=$(HOST_BUILD_DIR)/libbpf/ CC=$(HOSTCC) LD=$(HOSTLD) \
|
||||
|
|
@ -258,6 +265,7 @@ $(RESOLVE_BTFIDS): $(HOST_BPFOBJ) | $(HOST_BUILD_DIR)/resolve_btfids \
|
|||
$(TOOLSDIR)/lib/str_error_r.c
|
||||
$(Q)$(MAKE) $(submake_extras) -C $(TOOLSDIR)/bpf/resolve_btfids \
|
||||
CC=$(HOSTCC) LD=$(HOSTLD) AR=$(HOSTAR) \
|
||||
LIBBPF_INCLUDE=$(HOST_INCLUDE_DIR) \
|
||||
OUTPUT=$(HOST_BUILD_DIR)/resolve_btfids/ BPFOBJ=$(HOST_BPFOBJ)
|
||||
|
||||
# Get Clang's default includes on this system, as opposed to those seen by
|
||||
|
|
@ -269,7 +277,7 @@ $(RESOLVE_BTFIDS): $(HOST_BPFOBJ) | $(HOST_BUILD_DIR)/resolve_btfids \
|
|||
define get_sys_includes
|
||||
$(shell $(1) -v -E - </dev/null 2>&1 \
|
||||
| sed -n '/<...> search starts here:/,/End of search list./{ s| \(/.*\)|-idirafter \1|p }') \
|
||||
$(shell $(1) -dM -E - </dev/null | grep '#define __riscv_xlen ' | sed 's/#define /-D/' | sed 's/ /=/')
|
||||
$(shell $(1) -dM -E - </dev/null | grep '__riscv_xlen ' | awk '{printf("-D__riscv_xlen=%d -D__BITS_PER_LONG=%d", $$3, $$3)}')
|
||||
endef
|
||||
|
||||
# Determine target endianness.
|
||||
|
|
@ -315,7 +323,9 @@ LINKED_SKELS := test_static_linked.skel.h linked_funcs.skel.h \
|
|||
linked_vars.skel.h linked_maps.skel.h
|
||||
|
||||
LSKELS := kfunc_call_test.c fentry_test.c fexit_test.c fexit_sleep.c \
|
||||
test_ksyms_module.c test_ringbuf.c atomics.c trace_printk.c
|
||||
test_ringbuf.c atomics.c trace_printk.c trace_vprintk.c
|
||||
# Generate both light skeleton and libbpf skeleton for these
|
||||
LSKELS_EXTRA := test_ksyms_module.c test_ksyms_weak.c
|
||||
SKEL_BLACKLIST += $$(LSKELS)
|
||||
|
||||
test_static_linked.skel.h-deps := test_static_linked1.o test_static_linked2.o
|
||||
|
|
@ -345,7 +355,7 @@ TRUNNER_BPF_OBJS := $$(patsubst %.c,$$(TRUNNER_OUTPUT)/%.o, $$(TRUNNER_BPF_SRCS)
|
|||
TRUNNER_BPF_SKELS := $$(patsubst %.c,$$(TRUNNER_OUTPUT)/%.skel.h, \
|
||||
$$(filter-out $(SKEL_BLACKLIST) $(LINKED_BPF_SRCS),\
|
||||
$$(TRUNNER_BPF_SRCS)))
|
||||
TRUNNER_BPF_LSKELS := $$(patsubst %.c,$$(TRUNNER_OUTPUT)/%.lskel.h, $$(LSKELS))
|
||||
TRUNNER_BPF_LSKELS := $$(patsubst %.c,$$(TRUNNER_OUTPUT)/%.lskel.h, $$(LSKELS) $$(LSKELS_EXTRA))
|
||||
TRUNNER_BPF_SKELS_LINKED := $$(addprefix $$(TRUNNER_OUTPUT)/,$(LINKED_SKELS))
|
||||
TEST_GEN_FILES += $$(TRUNNER_BPF_OBJS)
|
||||
|
||||
|
|
@ -394,7 +404,7 @@ $(TRUNNER_BPF_LSKELS): %.lskel.h: %.o $(BPFTOOL) | $(TRUNNER_OUTPUT)
|
|||
$(Q)$$(BPFTOOL) gen object $$(<:.o=.linked2.o) $$(<:.o=.linked1.o)
|
||||
$(Q)$$(BPFTOOL) gen object $$(<:.o=.linked3.o) $$(<:.o=.linked2.o)
|
||||
$(Q)diff $$(<:.o=.linked2.o) $$(<:.o=.linked3.o)
|
||||
$(Q)$$(BPFTOOL) gen skeleton -L $$(<:.o=.linked3.o) name $$(notdir $$(<:.o=)) > $$@
|
||||
$(Q)$$(BPFTOOL) gen skeleton -L $$(<:.o=.linked3.o) name $$(notdir $$(<:.o=_lskel)) > $$@
|
||||
|
||||
$(TRUNNER_BPF_SKELS_LINKED): $(TRUNNER_BPF_OBJS) $(BPFTOOL) | $(TRUNNER_OUTPUT)
|
||||
$$(call msg,LINK-BPF,$(TRUNNER_BINARY),$$(@:.skel.h=.o))
|
||||
|
|
@ -411,10 +421,9 @@ ifeq ($($(TRUNNER_TESTS_DIR)-tests-hdr),)
|
|||
$(TRUNNER_TESTS_DIR)-tests-hdr := y
|
||||
$(TRUNNER_TESTS_HDR): $(TRUNNER_TESTS_DIR)/*.c
|
||||
$$(call msg,TEST-HDR,$(TRUNNER_BINARY),$$@)
|
||||
$$(shell ( cd $(TRUNNER_TESTS_DIR); \
|
||||
echo '/* Generated header, do not edit */'; \
|
||||
ls *.c 2> /dev/null | \
|
||||
sed -e 's@\([^\.]*\)\.c@DEFINE_TEST(\1)@'; \
|
||||
$$(shell (echo '/* Generated header, do not edit */'; \
|
||||
sed -n -E 's/^void (serial_)?test_([a-zA-Z0-9_]+)\((void)?\).*/DEFINE_TEST(\2)/p' \
|
||||
$(TRUNNER_TESTS_DIR)/*.c | sort ; \
|
||||
) > $$@)
|
||||
endif
|
||||
|
||||
|
|
@ -453,7 +462,7 @@ $(OUTPUT)/$(TRUNNER_BINARY): $(TRUNNER_TEST_OBJS) \
|
|||
| $(TRUNNER_BINARY)-extras
|
||||
$$(call msg,BINARY,,$$@)
|
||||
$(Q)$$(CC) $$(CFLAGS) $$(filter %.a %.o,$$^) $$(LDLIBS) -o $$@
|
||||
$(Q)$(RESOLVE_BTFIDS) --no-fail --btf $(TRUNNER_OUTPUT)/btf_data.o $$@
|
||||
$(Q)$(RESOLVE_BTFIDS) --btf $(TRUNNER_OUTPUT)/btf_data.o $$@
|
||||
|
||||
endef
|
||||
|
||||
|
|
@ -513,20 +522,22 @@ $(OUTPUT)/test_cpp: test_cpp.cpp $(OUTPUT)/test_core_extern.skel.h $(BPFOBJ)
|
|||
$(Q)$(CXX) $(CFLAGS) $(filter %.a %.o %.cpp,$^) $(LDLIBS) -o $@
|
||||
|
||||
# Benchmark runner
|
||||
$(OUTPUT)/bench_%.o: benchs/bench_%.c bench.h
|
||||
$(OUTPUT)/bench_%.o: benchs/bench_%.c bench.h $(BPFOBJ)
|
||||
$(call msg,CC,,$@)
|
||||
$(Q)$(CC) $(CFLAGS) -c $(filter %.c,$^) $(LDLIBS) -o $@
|
||||
$(Q)$(CC) $(CFLAGS) -O2 -c $(filter %.c,$^) $(LDLIBS) -o $@
|
||||
$(OUTPUT)/bench_rename.o: $(OUTPUT)/test_overhead.skel.h
|
||||
$(OUTPUT)/bench_trigger.o: $(OUTPUT)/trigger_bench.skel.h
|
||||
$(OUTPUT)/bench_ringbufs.o: $(OUTPUT)/ringbuf_bench.skel.h \
|
||||
$(OUTPUT)/perfbuf_bench.skel.h
|
||||
$(OUTPUT)/bench.o: bench.h testing_helpers.h
|
||||
$(OUTPUT)/bench_bloom_filter_map.o: $(OUTPUT)/bloom_filter_bench.skel.h
|
||||
$(OUTPUT)/bench.o: bench.h testing_helpers.h $(BPFOBJ)
|
||||
$(OUTPUT)/bench: LDLIBS += -lm
|
||||
$(OUTPUT)/bench: $(OUTPUT)/bench.o $(OUTPUT)/testing_helpers.o \
|
||||
$(OUTPUT)/bench_count.o \
|
||||
$(OUTPUT)/bench_rename.o \
|
||||
$(OUTPUT)/bench_trigger.o \
|
||||
$(OUTPUT)/bench_ringbufs.o
|
||||
$(OUTPUT)/bench_ringbufs.o \
|
||||
$(OUTPUT)/bench_bloom_filter_map.o
|
||||
$(call msg,BINARY,,$@)
|
||||
$(Q)$(CC) $(LDFLAGS) -o $@ $(filter %.a %.o,$^) $(LDLIBS)
|
||||
|
||||
|
|
|
|||
|
|
@ -201,6 +201,20 @@ Without it, the error from compiling bpf selftests looks like:
|
|||
|
||||
__ https://reviews.llvm.org/D93563
|
||||
|
||||
btf_tag test and Clang version
|
||||
==============================
|
||||
|
||||
The btf_tag selftest require LLVM support to recognize the btf_decl_tag attribute.
|
||||
It was introduced in `Clang 14`__.
|
||||
|
||||
Without it, the btf_tag selftest will be skipped and you will observe:
|
||||
|
||||
.. code-block:: console
|
||||
|
||||
#<test_num> btf_tag:SKIP
|
||||
|
||||
__ https://reviews.llvm.org/D111588
|
||||
|
||||
Clang dependencies for static linking tests
|
||||
===========================================
|
||||
|
||||
|
|
@ -228,3 +242,16 @@ To fix this issue, user newer libbpf.
|
|||
.. Links
|
||||
.. _clang reloc patch: https://reviews.llvm.org/D102712
|
||||
.. _kernel llvm reloc: /Documentation/bpf/llvm_reloc.rst
|
||||
|
||||
Clang dependencies for the u32 spill test (xdpwall)
|
||||
===================================================
|
||||
The xdpwall selftest requires a change in `Clang 14`__.
|
||||
|
||||
Without it, the xdpwall selftest will fail and the error message
|
||||
from running test_progs will look like:
|
||||
|
||||
.. code-block:: console
|
||||
|
||||
test_xdpwall:FAIL:Does LLVM have https://reviews.llvm.org/D109073? unexpected error: -4007
|
||||
|
||||
__ https://reviews.llvm.org/D109073
|
||||
|
|
|
|||
|
|
@ -51,6 +51,35 @@ void setup_libbpf()
|
|||
fprintf(stderr, "failed to increase RLIMIT_MEMLOCK: %d", err);
|
||||
}
|
||||
|
||||
void false_hits_report_progress(int iter, struct bench_res *res, long delta_ns)
|
||||
{
|
||||
long total = res->false_hits + res->hits + res->drops;
|
||||
|
||||
printf("Iter %3d (%7.3lfus): ",
|
||||
iter, (delta_ns - 1000000000) / 1000.0);
|
||||
|
||||
printf("%ld false hits of %ld total operations. Percentage = %2.2f %%\n",
|
||||
res->false_hits, total, ((float)res->false_hits / total) * 100);
|
||||
}
|
||||
|
||||
void false_hits_report_final(struct bench_res res[], int res_cnt)
|
||||
{
|
||||
long total_hits = 0, total_drops = 0, total_false_hits = 0, total_ops = 0;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < res_cnt; i++) {
|
||||
total_hits += res[i].hits;
|
||||
total_false_hits += res[i].false_hits;
|
||||
total_drops += res[i].drops;
|
||||
}
|
||||
total_ops = total_hits + total_false_hits + total_drops;
|
||||
|
||||
printf("Summary: %ld false hits of %ld total operations. ",
|
||||
total_false_hits, total_ops);
|
||||
printf("Percentage = %2.2f %%\n",
|
||||
((float)total_false_hits / total_ops) * 100);
|
||||
}
|
||||
|
||||
void hits_drops_report_progress(int iter, struct bench_res *res, long delta_ns)
|
||||
{
|
||||
double hits_per_sec, drops_per_sec;
|
||||
|
|
@ -63,20 +92,22 @@ void hits_drops_report_progress(int iter, struct bench_res *res, long delta_ns)
|
|||
printf("Iter %3d (%7.3lfus): ",
|
||||
iter, (delta_ns - 1000000000) / 1000.0);
|
||||
|
||||
printf("hits %8.3lfM/s (%7.3lfM/prod), drops %8.3lfM/s\n",
|
||||
hits_per_sec, hits_per_prod, drops_per_sec);
|
||||
printf("hits %8.3lfM/s (%7.3lfM/prod), drops %8.3lfM/s, total operations %8.3lfM/s\n",
|
||||
hits_per_sec, hits_per_prod, drops_per_sec, hits_per_sec + drops_per_sec);
|
||||
}
|
||||
|
||||
void hits_drops_report_final(struct bench_res res[], int res_cnt)
|
||||
{
|
||||
int i;
|
||||
double hits_mean = 0.0, drops_mean = 0.0;
|
||||
double hits_stddev = 0.0, drops_stddev = 0.0;
|
||||
double hits_mean = 0.0, drops_mean = 0.0, total_ops_mean = 0.0;
|
||||
double hits_stddev = 0.0, drops_stddev = 0.0, total_ops_stddev = 0.0;
|
||||
double total_ops;
|
||||
|
||||
for (i = 0; i < res_cnt; i++) {
|
||||
hits_mean += res[i].hits / 1000000.0 / (0.0 + res_cnt);
|
||||
drops_mean += res[i].drops / 1000000.0 / (0.0 + res_cnt);
|
||||
}
|
||||
total_ops_mean = hits_mean + drops_mean;
|
||||
|
||||
if (res_cnt > 1) {
|
||||
for (i = 0; i < res_cnt; i++) {
|
||||
|
|
@ -86,14 +117,21 @@ void hits_drops_report_final(struct bench_res res[], int res_cnt)
|
|||
drops_stddev += (drops_mean - res[i].drops / 1000000.0) *
|
||||
(drops_mean - res[i].drops / 1000000.0) /
|
||||
(res_cnt - 1.0);
|
||||
total_ops = res[i].hits + res[i].drops;
|
||||
total_ops_stddev += (total_ops_mean - total_ops / 1000000.0) *
|
||||
(total_ops_mean - total_ops / 1000000.0) /
|
||||
(res_cnt - 1.0);
|
||||
}
|
||||
hits_stddev = sqrt(hits_stddev);
|
||||
drops_stddev = sqrt(drops_stddev);
|
||||
total_ops_stddev = sqrt(total_ops_stddev);
|
||||
}
|
||||
printf("Summary: hits %8.3lf \u00B1 %5.3lfM/s (%7.3lfM/prod), ",
|
||||
hits_mean, hits_stddev, hits_mean / env.producer_cnt);
|
||||
printf("drops %8.3lf \u00B1 %5.3lfM/s\n",
|
||||
printf("drops %8.3lf \u00B1 %5.3lfM/s, ",
|
||||
drops_mean, drops_stddev);
|
||||
printf("total operations %8.3lf \u00B1 %5.3lfM/s\n",
|
||||
total_ops_mean, total_ops_stddev);
|
||||
}
|
||||
|
||||
const char *argp_program_version = "benchmark";
|
||||
|
|
@ -132,9 +170,11 @@ static const struct argp_option opts[] = {
|
|||
};
|
||||
|
||||
extern struct argp bench_ringbufs_argp;
|
||||
extern struct argp bench_bloom_map_argp;
|
||||
|
||||
static const struct argp_child bench_parsers[] = {
|
||||
{ &bench_ringbufs_argp, 0, "Ring buffers benchmark", 0 },
|
||||
{ &bench_bloom_map_argp, 0, "Bloom filter map benchmark", 0 },
|
||||
{},
|
||||
};
|
||||
|
||||
|
|
@ -323,6 +363,11 @@ extern const struct bench bench_rb_libbpf;
|
|||
extern const struct bench bench_rb_custom;
|
||||
extern const struct bench bench_pb_libbpf;
|
||||
extern const struct bench bench_pb_custom;
|
||||
extern const struct bench bench_bloom_lookup;
|
||||
extern const struct bench bench_bloom_update;
|
||||
extern const struct bench bench_bloom_false_positive;
|
||||
extern const struct bench bench_hashmap_without_bloom;
|
||||
extern const struct bench bench_hashmap_with_bloom;
|
||||
|
||||
static const struct bench *benchs[] = {
|
||||
&bench_count_global,
|
||||
|
|
@ -344,6 +389,11 @@ static const struct bench *benchs[] = {
|
|||
&bench_rb_custom,
|
||||
&bench_pb_libbpf,
|
||||
&bench_pb_custom,
|
||||
&bench_bloom_lookup,
|
||||
&bench_bloom_update,
|
||||
&bench_bloom_false_positive,
|
||||
&bench_hashmap_without_bloom,
|
||||
&bench_hashmap_with_bloom,
|
||||
};
|
||||
|
||||
static void setup_benchmark()
|
||||
|
|
|
|||
|
|
@ -33,6 +33,7 @@ struct env {
|
|||
struct bench_res {
|
||||
long hits;
|
||||
long drops;
|
||||
long false_hits;
|
||||
};
|
||||
|
||||
struct bench {
|
||||
|
|
@ -56,6 +57,8 @@ extern const struct bench *bench;
|
|||
void setup_libbpf();
|
||||
void hits_drops_report_progress(int iter, struct bench_res *res, long delta_ns);
|
||||
void hits_drops_report_final(struct bench_res res[], int res_cnt);
|
||||
void false_hits_report_progress(int iter, struct bench_res *res, long delta_ns);
|
||||
void false_hits_report_final(struct bench_res res[], int res_cnt);
|
||||
|
||||
static inline __u64 get_time_ns() {
|
||||
struct timespec t;
|
||||
|
|
|
|||
477
tools/testing/selftests/bpf/benchs/bench_bloom_filter_map.c
Normal file
477
tools/testing/selftests/bpf/benchs/bench_bloom_filter_map.c
Normal file
|
|
@ -0,0 +1,477 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Copyright (c) 2021 Facebook */
|
||||
|
||||
#include <argp.h>
|
||||
#include <linux/log2.h>
|
||||
#include <pthread.h>
|
||||
#include "bench.h"
|
||||
#include "bloom_filter_bench.skel.h"
|
||||
#include "bpf_util.h"
|
||||
|
||||
static struct ctx {
|
||||
bool use_array_map;
|
||||
bool use_hashmap;
|
||||
bool hashmap_use_bloom;
|
||||
bool count_false_hits;
|
||||
|
||||
struct bloom_filter_bench *skel;
|
||||
|
||||
int bloom_fd;
|
||||
int hashmap_fd;
|
||||
int array_map_fd;
|
||||
|
||||
pthread_mutex_t map_done_mtx;
|
||||
pthread_cond_t map_done_cv;
|
||||
bool map_done;
|
||||
bool map_prepare_err;
|
||||
|
||||
__u32 next_map_idx;
|
||||
} ctx = {
|
||||
.map_done_mtx = PTHREAD_MUTEX_INITIALIZER,
|
||||
.map_done_cv = PTHREAD_COND_INITIALIZER,
|
||||
};
|
||||
|
||||
struct stat {
|
||||
__u32 stats[3];
|
||||
};
|
||||
|
||||
static struct {
|
||||
__u32 nr_entries;
|
||||
__u8 nr_hash_funcs;
|
||||
__u8 value_size;
|
||||
} args = {
|
||||
.nr_entries = 1000,
|
||||
.nr_hash_funcs = 3,
|
||||
.value_size = 8,
|
||||
};
|
||||
|
||||
enum {
|
||||
ARG_NR_ENTRIES = 3000,
|
||||
ARG_NR_HASH_FUNCS = 3001,
|
||||
ARG_VALUE_SIZE = 3002,
|
||||
};
|
||||
|
||||
static const struct argp_option opts[] = {
|
||||
{ "nr_entries", ARG_NR_ENTRIES, "NR_ENTRIES", 0,
|
||||
"Set number of expected unique entries in the bloom filter"},
|
||||
{ "nr_hash_funcs", ARG_NR_HASH_FUNCS, "NR_HASH_FUNCS", 0,
|
||||
"Set number of hash functions in the bloom filter"},
|
||||
{ "value_size", ARG_VALUE_SIZE, "VALUE_SIZE", 0,
|
||||
"Set value size (in bytes) of bloom filter entries"},
|
||||
{},
|
||||
};
|
||||
|
||||
static error_t parse_arg(int key, char *arg, struct argp_state *state)
|
||||
{
|
||||
switch (key) {
|
||||
case ARG_NR_ENTRIES:
|
||||
args.nr_entries = strtol(arg, NULL, 10);
|
||||
if (args.nr_entries == 0) {
|
||||
fprintf(stderr, "Invalid nr_entries count.");
|
||||
argp_usage(state);
|
||||
}
|
||||
break;
|
||||
case ARG_NR_HASH_FUNCS:
|
||||
args.nr_hash_funcs = strtol(arg, NULL, 10);
|
||||
if (args.nr_hash_funcs == 0 || args.nr_hash_funcs > 15) {
|
||||
fprintf(stderr,
|
||||
"The bloom filter must use 1 to 15 hash functions.");
|
||||
argp_usage(state);
|
||||
}
|
||||
break;
|
||||
case ARG_VALUE_SIZE:
|
||||
args.value_size = strtol(arg, NULL, 10);
|
||||
if (args.value_size < 2 || args.value_size > 256) {
|
||||
fprintf(stderr,
|
||||
"Invalid value size. Must be between 2 and 256 bytes");
|
||||
argp_usage(state);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return ARGP_ERR_UNKNOWN;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* exported into benchmark runner */
|
||||
const struct argp bench_bloom_map_argp = {
|
||||
.options = opts,
|
||||
.parser = parse_arg,
|
||||
};
|
||||
|
||||
static void validate(void)
|
||||
{
|
||||
if (env.consumer_cnt != 1) {
|
||||
fprintf(stderr,
|
||||
"The bloom filter benchmarks do not support multi-consumer use\n");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void trigger_bpf_program(void)
|
||||
{
|
||||
syscall(__NR_getpgid);
|
||||
}
|
||||
|
||||
static void *producer(void *input)
|
||||
{
|
||||
while (true)
|
||||
trigger_bpf_program();
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void *map_prepare_thread(void *arg)
|
||||
{
|
||||
__u32 val_size, i;
|
||||
void *val = NULL;
|
||||
int err;
|
||||
|
||||
val_size = args.value_size;
|
||||
val = malloc(val_size);
|
||||
if (!val) {
|
||||
ctx.map_prepare_err = true;
|
||||
goto done;
|
||||
}
|
||||
|
||||
while (true) {
|
||||
i = __atomic_add_fetch(&ctx.next_map_idx, 1, __ATOMIC_RELAXED);
|
||||
if (i > args.nr_entries)
|
||||
break;
|
||||
|
||||
again:
|
||||
/* Populate hashmap, bloom filter map, and array map with the same
|
||||
* random values
|
||||
*/
|
||||
err = syscall(__NR_getrandom, val, val_size, 0);
|
||||
if (err != val_size) {
|
||||
ctx.map_prepare_err = true;
|
||||
fprintf(stderr, "failed to get random value: %d\n", -errno);
|
||||
break;
|
||||
}
|
||||
|
||||
if (ctx.use_hashmap) {
|
||||
err = bpf_map_update_elem(ctx.hashmap_fd, val, val, BPF_NOEXIST);
|
||||
if (err) {
|
||||
if (err != -EEXIST) {
|
||||
ctx.map_prepare_err = true;
|
||||
fprintf(stderr, "failed to add elem to hashmap: %d\n",
|
||||
-errno);
|
||||
break;
|
||||
}
|
||||
goto again;
|
||||
}
|
||||
}
|
||||
|
||||
i--;
|
||||
|
||||
if (ctx.use_array_map) {
|
||||
err = bpf_map_update_elem(ctx.array_map_fd, &i, val, 0);
|
||||
if (err) {
|
||||
ctx.map_prepare_err = true;
|
||||
fprintf(stderr, "failed to add elem to array map: %d\n", -errno);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (ctx.use_hashmap && !ctx.hashmap_use_bloom)
|
||||
continue;
|
||||
|
||||
err = bpf_map_update_elem(ctx.bloom_fd, NULL, val, 0);
|
||||
if (err) {
|
||||
ctx.map_prepare_err = true;
|
||||
fprintf(stderr,
|
||||
"failed to add elem to bloom filter map: %d\n", -errno);
|
||||
break;
|
||||
}
|
||||
}
|
||||
done:
|
||||
pthread_mutex_lock(&ctx.map_done_mtx);
|
||||
ctx.map_done = true;
|
||||
pthread_cond_signal(&ctx.map_done_cv);
|
||||
pthread_mutex_unlock(&ctx.map_done_mtx);
|
||||
|
||||
if (val)
|
||||
free(val);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void populate_maps(void)
|
||||
{
|
||||
unsigned int nr_cpus = bpf_num_possible_cpus();
|
||||
pthread_t map_thread;
|
||||
int i, err, nr_rand_bytes;
|
||||
|
||||
ctx.bloom_fd = bpf_map__fd(ctx.skel->maps.bloom_map);
|
||||
ctx.hashmap_fd = bpf_map__fd(ctx.skel->maps.hashmap);
|
||||
ctx.array_map_fd = bpf_map__fd(ctx.skel->maps.array_map);
|
||||
|
||||
for (i = 0; i < nr_cpus; i++) {
|
||||
err = pthread_create(&map_thread, NULL, map_prepare_thread,
|
||||
NULL);
|
||||
if (err) {
|
||||
fprintf(stderr, "failed to create pthread: %d\n", -errno);
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
pthread_mutex_lock(&ctx.map_done_mtx);
|
||||
while (!ctx.map_done)
|
||||
pthread_cond_wait(&ctx.map_done_cv, &ctx.map_done_mtx);
|
||||
pthread_mutex_unlock(&ctx.map_done_mtx);
|
||||
|
||||
if (ctx.map_prepare_err)
|
||||
exit(1);
|
||||
|
||||
nr_rand_bytes = syscall(__NR_getrandom, ctx.skel->bss->rand_vals,
|
||||
ctx.skel->rodata->nr_rand_bytes, 0);
|
||||
if (nr_rand_bytes != ctx.skel->rodata->nr_rand_bytes) {
|
||||
fprintf(stderr, "failed to get random bytes\n");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
static void check_args(void)
|
||||
{
|
||||
if (args.value_size < 8) {
|
||||
__u64 nr_unique_entries = 1ULL << (args.value_size * 8);
|
||||
|
||||
if (args.nr_entries > nr_unique_entries) {
|
||||
fprintf(stderr,
|
||||
"Not enough unique values for the nr_entries requested\n");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static struct bloom_filter_bench *setup_skeleton(void)
|
||||
{
|
||||
struct bloom_filter_bench *skel;
|
||||
|
||||
check_args();
|
||||
|
||||
setup_libbpf();
|
||||
|
||||
skel = bloom_filter_bench__open();
|
||||
if (!skel) {
|
||||
fprintf(stderr, "failed to open skeleton\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
skel->rodata->hashmap_use_bloom = ctx.hashmap_use_bloom;
|
||||
skel->rodata->count_false_hits = ctx.count_false_hits;
|
||||
|
||||
/* Resize number of entries */
|
||||
bpf_map__set_max_entries(skel->maps.hashmap, args.nr_entries);
|
||||
|
||||
bpf_map__set_max_entries(skel->maps.array_map, args.nr_entries);
|
||||
|
||||
bpf_map__set_max_entries(skel->maps.bloom_map, args.nr_entries);
|
||||
|
||||
/* Set value size */
|
||||
bpf_map__set_value_size(skel->maps.array_map, args.value_size);
|
||||
|
||||
bpf_map__set_value_size(skel->maps.bloom_map, args.value_size);
|
||||
|
||||
bpf_map__set_value_size(skel->maps.hashmap, args.value_size);
|
||||
|
||||
/* For the hashmap, we use the value as the key as well */
|
||||
bpf_map__set_key_size(skel->maps.hashmap, args.value_size);
|
||||
|
||||
skel->bss->value_size = args.value_size;
|
||||
|
||||
/* Set number of hash functions */
|
||||
bpf_map__set_map_extra(skel->maps.bloom_map, args.nr_hash_funcs);
|
||||
|
||||
if (bloom_filter_bench__load(skel)) {
|
||||
fprintf(stderr, "failed to load skeleton\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
return skel;
|
||||
}
|
||||
|
||||
static void bloom_lookup_setup(void)
|
||||
{
|
||||
struct bpf_link *link;
|
||||
|
||||
ctx.use_array_map = true;
|
||||
|
||||
ctx.skel = setup_skeleton();
|
||||
|
||||
populate_maps();
|
||||
|
||||
link = bpf_program__attach(ctx.skel->progs.bloom_lookup);
|
||||
if (!link) {
|
||||
fprintf(stderr, "failed to attach program!\n");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
static void bloom_update_setup(void)
|
||||
{
|
||||
struct bpf_link *link;
|
||||
|
||||
ctx.use_array_map = true;
|
||||
|
||||
ctx.skel = setup_skeleton();
|
||||
|
||||
populate_maps();
|
||||
|
||||
link = bpf_program__attach(ctx.skel->progs.bloom_update);
|
||||
if (!link) {
|
||||
fprintf(stderr, "failed to attach program!\n");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
static void false_positive_setup(void)
|
||||
{
|
||||
struct bpf_link *link;
|
||||
|
||||
ctx.use_hashmap = true;
|
||||
ctx.hashmap_use_bloom = true;
|
||||
ctx.count_false_hits = true;
|
||||
|
||||
ctx.skel = setup_skeleton();
|
||||
|
||||
populate_maps();
|
||||
|
||||
link = bpf_program__attach(ctx.skel->progs.bloom_hashmap_lookup);
|
||||
if (!link) {
|
||||
fprintf(stderr, "failed to attach program!\n");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
static void hashmap_with_bloom_setup(void)
|
||||
{
|
||||
struct bpf_link *link;
|
||||
|
||||
ctx.use_hashmap = true;
|
||||
ctx.hashmap_use_bloom = true;
|
||||
|
||||
ctx.skel = setup_skeleton();
|
||||
|
||||
populate_maps();
|
||||
|
||||
link = bpf_program__attach(ctx.skel->progs.bloom_hashmap_lookup);
|
||||
if (!link) {
|
||||
fprintf(stderr, "failed to attach program!\n");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
static void hashmap_no_bloom_setup(void)
|
||||
{
|
||||
struct bpf_link *link;
|
||||
|
||||
ctx.use_hashmap = true;
|
||||
|
||||
ctx.skel = setup_skeleton();
|
||||
|
||||
populate_maps();
|
||||
|
||||
link = bpf_program__attach(ctx.skel->progs.bloom_hashmap_lookup);
|
||||
if (!link) {
|
||||
fprintf(stderr, "failed to attach program!\n");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
static void measure(struct bench_res *res)
|
||||
{
|
||||
unsigned long total_hits = 0, total_drops = 0, total_false_hits = 0;
|
||||
static unsigned long last_hits, last_drops, last_false_hits;
|
||||
unsigned int nr_cpus = bpf_num_possible_cpus();
|
||||
int hit_key, drop_key, false_hit_key;
|
||||
int i;
|
||||
|
||||
hit_key = ctx.skel->rodata->hit_key;
|
||||
drop_key = ctx.skel->rodata->drop_key;
|
||||
false_hit_key = ctx.skel->rodata->false_hit_key;
|
||||
|
||||
if (ctx.skel->bss->error != 0) {
|
||||
fprintf(stderr, "error (%d) when searching the bloom filter\n",
|
||||
ctx.skel->bss->error);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
for (i = 0; i < nr_cpus; i++) {
|
||||
struct stat *s = (void *)&ctx.skel->bss->percpu_stats[i];
|
||||
|
||||
total_hits += s->stats[hit_key];
|
||||
total_drops += s->stats[drop_key];
|
||||
total_false_hits += s->stats[false_hit_key];
|
||||
}
|
||||
|
||||
res->hits = total_hits - last_hits;
|
||||
res->drops = total_drops - last_drops;
|
||||
res->false_hits = total_false_hits - last_false_hits;
|
||||
|
||||
last_hits = total_hits;
|
||||
last_drops = total_drops;
|
||||
last_false_hits = total_false_hits;
|
||||
}
|
||||
|
||||
static void *consumer(void *input)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const struct bench bench_bloom_lookup = {
|
||||
.name = "bloom-lookup",
|
||||
.validate = validate,
|
||||
.setup = bloom_lookup_setup,
|
||||
.producer_thread = producer,
|
||||
.consumer_thread = consumer,
|
||||
.measure = measure,
|
||||
.report_progress = hits_drops_report_progress,
|
||||
.report_final = hits_drops_report_final,
|
||||
};
|
||||
|
||||
const struct bench bench_bloom_update = {
|
||||
.name = "bloom-update",
|
||||
.validate = validate,
|
||||
.setup = bloom_update_setup,
|
||||
.producer_thread = producer,
|
||||
.consumer_thread = consumer,
|
||||
.measure = measure,
|
||||
.report_progress = hits_drops_report_progress,
|
||||
.report_final = hits_drops_report_final,
|
||||
};
|
||||
|
||||
const struct bench bench_bloom_false_positive = {
|
||||
.name = "bloom-false-positive",
|
||||
.validate = validate,
|
||||
.setup = false_positive_setup,
|
||||
.producer_thread = producer,
|
||||
.consumer_thread = consumer,
|
||||
.measure = measure,
|
||||
.report_progress = false_hits_report_progress,
|
||||
.report_final = false_hits_report_final,
|
||||
};
|
||||
|
||||
const struct bench bench_hashmap_without_bloom = {
|
||||
.name = "hashmap-without-bloom",
|
||||
.validate = validate,
|
||||
.setup = hashmap_no_bloom_setup,
|
||||
.producer_thread = producer,
|
||||
.consumer_thread = consumer,
|
||||
.measure = measure,
|
||||
.report_progress = hits_drops_report_progress,
|
||||
.report_final = hits_drops_report_final,
|
||||
};
|
||||
|
||||
const struct bench bench_hashmap_with_bloom = {
|
||||
.name = "hashmap-with-bloom",
|
||||
.validate = validate,
|
||||
.setup = hashmap_with_bloom_setup,
|
||||
.producer_thread = producer,
|
||||
.consumer_thread = consumer,
|
||||
.measure = measure,
|
||||
.report_progress = hits_drops_report_progress,
|
||||
.report_final = hits_drops_report_final,
|
||||
};
|
||||
45
tools/testing/selftests/bpf/benchs/run_bench_bloom_filter_map.sh
Executable file
45
tools/testing/selftests/bpf/benchs/run_bench_bloom_filter_map.sh
Executable file
|
|
@ -0,0 +1,45 @@
|
|||
#!/bin/bash
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
|
||||
source ./benchs/run_common.sh
|
||||
|
||||
set -eufo pipefail
|
||||
|
||||
header "Bloom filter map"
|
||||
for v in 2 4 8 16 40; do
|
||||
for t in 1 4 8 12 16; do
|
||||
for h in {1..10}; do
|
||||
subtitle "value_size: $v bytes, # threads: $t, # hashes: $h"
|
||||
for e in 10000 50000 75000 100000 250000 500000 750000 1000000 2500000 5000000; do
|
||||
printf "%'d entries -\n" $e
|
||||
printf "\t"
|
||||
summarize "Lookups, total operations: " \
|
||||
"$($RUN_BENCH -p $t --nr_hash_funcs $h --nr_entries $e --value_size $v bloom-lookup)"
|
||||
printf "\t"
|
||||
summarize "Updates, total operations: " \
|
||||
"$($RUN_BENCH -p $t --nr_hash_funcs $h --nr_entries $e --value_size $v bloom-update)"
|
||||
printf "\t"
|
||||
summarize_percentage "False positive rate: " \
|
||||
"$($RUN_BENCH -p $t --nr_hash_funcs $h --nr_entries $e --value_size $v bloom-false-positive)"
|
||||
done
|
||||
printf "\n"
|
||||
done
|
||||
done
|
||||
done
|
||||
|
||||
header "Hashmap without bloom filter vs. hashmap with bloom filter (throughput, 8 threads)"
|
||||
for v in 2 4 8 16 40; do
|
||||
for h in {1..10}; do
|
||||
subtitle "value_size: $v, # hashes: $h"
|
||||
for e in 10000 50000 75000 100000 250000 500000 750000 1000000 2500000 5000000; do
|
||||
printf "%'d entries -\n" $e
|
||||
printf "\t"
|
||||
summarize_total "Hashmap without bloom filter: " \
|
||||
"$($RUN_BENCH --nr_hash_funcs $h --nr_entries $e --value_size $v -p 8 hashmap-without-bloom)"
|
||||
printf "\t"
|
||||
summarize_total "Hashmap with bloom filter: " \
|
||||
"$($RUN_BENCH --nr_hash_funcs $h --nr_entries $e --value_size $v -p 8 hashmap-with-bloom)"
|
||||
done
|
||||
printf "\n"
|
||||
done
|
||||
done
|
||||
|
|
@ -1,35 +1,9 @@
|
|||
#!/bin/bash
|
||||
|
||||
source ./benchs/run_common.sh
|
||||
|
||||
set -eufo pipefail
|
||||
|
||||
RUN_BENCH="sudo ./bench -w3 -d10 -a"
|
||||
|
||||
function hits()
|
||||
{
|
||||
echo "$*" | sed -E "s/.*hits\s+([0-9]+\.[0-9]+ ± [0-9]+\.[0-9]+M\/s).*/\1/"
|
||||
}
|
||||
|
||||
function drops()
|
||||
{
|
||||
echo "$*" | sed -E "s/.*drops\s+([0-9]+\.[0-9]+ ± [0-9]+\.[0-9]+M\/s).*/\1/"
|
||||
}
|
||||
|
||||
function header()
|
||||
{
|
||||
local len=${#1}
|
||||
|
||||
printf "\n%s\n" "$1"
|
||||
for i in $(seq 1 $len); do printf '='; done
|
||||
printf '\n'
|
||||
}
|
||||
|
||||
function summarize()
|
||||
{
|
||||
bench="$1"
|
||||
summary=$(echo $2 | tail -n1)
|
||||
printf "%-20s %s (drops %s)\n" "$bench" "$(hits $summary)" "$(drops $summary)"
|
||||
}
|
||||
|
||||
header "Single-producer, parallel producer"
|
||||
for b in rb-libbpf rb-custom pb-libbpf pb-custom; do
|
||||
summarize $b "$($RUN_BENCH $b)"
|
||||
|
|
|
|||
60
tools/testing/selftests/bpf/benchs/run_common.sh
Normal file
60
tools/testing/selftests/bpf/benchs/run_common.sh
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
#!/bin/bash
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
|
||||
RUN_BENCH="sudo ./bench -w3 -d10 -a"
|
||||
|
||||
function header()
|
||||
{
|
||||
local len=${#1}
|
||||
|
||||
printf "\n%s\n" "$1"
|
||||
for i in $(seq 1 $len); do printf '='; done
|
||||
printf '\n'
|
||||
}
|
||||
|
||||
function subtitle()
|
||||
{
|
||||
local len=${#1}
|
||||
printf "\t%s\n" "$1"
|
||||
}
|
||||
|
||||
function hits()
|
||||
{
|
||||
echo "$*" | sed -E "s/.*hits\s+([0-9]+\.[0-9]+ ± [0-9]+\.[0-9]+M\/s).*/\1/"
|
||||
}
|
||||
|
||||
function drops()
|
||||
{
|
||||
echo "$*" | sed -E "s/.*drops\s+([0-9]+\.[0-9]+ ± [0-9]+\.[0-9]+M\/s).*/\1/"
|
||||
}
|
||||
|
||||
function percentage()
|
||||
{
|
||||
echo "$*" | sed -E "s/.*Percentage\s=\s+([0-9]+\.[0-9]+).*/\1/"
|
||||
}
|
||||
|
||||
function total()
|
||||
{
|
||||
echo "$*" | sed -E "s/.*total operations\s+([0-9]+\.[0-9]+ ± [0-9]+\.[0-9]+M\/s).*/\1/"
|
||||
}
|
||||
|
||||
function summarize()
|
||||
{
|
||||
bench="$1"
|
||||
summary=$(echo $2 | tail -n1)
|
||||
printf "%-20s %s (drops %s)\n" "$bench" "$(hits $summary)" "$(drops $summary)"
|
||||
}
|
||||
|
||||
function summarize_percentage()
|
||||
{
|
||||
bench="$1"
|
||||
summary=$(echo $2 | tail -n1)
|
||||
printf "%-20s %s%%\n" "$bench" "$(percentage $summary)"
|
||||
}
|
||||
|
||||
function summarize_total()
|
||||
{
|
||||
bench="$1"
|
||||
summary=$(echo $2 | tail -n1)
|
||||
printf "%-20s %s\n" "$bench" "$(total $summary)"
|
||||
}
|
||||
|
|
@ -34,6 +34,21 @@ DECLARE_TRACE(bpf_testmod_test_write_bare,
|
|||
TP_ARGS(task, ctx)
|
||||
);
|
||||
|
||||
#undef BPF_TESTMOD_DECLARE_TRACE
|
||||
#ifdef DECLARE_TRACE_WRITABLE
|
||||
#define BPF_TESTMOD_DECLARE_TRACE(call, proto, args, size) \
|
||||
DECLARE_TRACE_WRITABLE(call, PARAMS(proto), PARAMS(args), size)
|
||||
#else
|
||||
#define BPF_TESTMOD_DECLARE_TRACE(call, proto, args, size) \
|
||||
DECLARE_TRACE(call, PARAMS(proto), PARAMS(args))
|
||||
#endif
|
||||
|
||||
BPF_TESTMOD_DECLARE_TRACE(bpf_testmod_test_writable_bare,
|
||||
TP_PROTO(struct bpf_testmod_test_writable_ctx *ctx),
|
||||
TP_ARGS(ctx),
|
||||
sizeof(struct bpf_testmod_test_writable_ctx)
|
||||
);
|
||||
|
||||
#endif /* _BPF_TESTMOD_EVENTS_H */
|
||||
|
||||
#undef TRACE_INCLUDE_PATH
|
||||
|
|
|
|||
|
|
@ -1,5 +1,7 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Copyright (c) 2020 Facebook */
|
||||
#include <linux/btf.h>
|
||||
#include <linux/btf_ids.h>
|
||||
#include <linux/error-injection.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/module.h>
|
||||
|
|
@ -13,6 +15,24 @@
|
|||
|
||||
DEFINE_PER_CPU(int, bpf_testmod_ksym_percpu) = 123;
|
||||
|
||||
noinline void
|
||||
bpf_testmod_test_mod_kfunc(int i)
|
||||
{
|
||||
*(int *)this_cpu_ptr(&bpf_testmod_ksym_percpu) = i;
|
||||
}
|
||||
|
||||
noinline int bpf_testmod_loop_test(int n)
|
||||
{
|
||||
int i, sum = 0;
|
||||
|
||||
/* the primary goal of this test is to test LBR. Create a lot of
|
||||
* branches in the function, so we can catch it easily.
|
||||
*/
|
||||
for (i = 0; i < n; i++)
|
||||
sum += i;
|
||||
return sum;
|
||||
}
|
||||
|
||||
noinline ssize_t
|
||||
bpf_testmod_test_read(struct file *file, struct kobject *kobj,
|
||||
struct bin_attribute *bin_attr,
|
||||
|
|
@ -24,7 +44,21 @@ bpf_testmod_test_read(struct file *file, struct kobject *kobj,
|
|||
.len = len,
|
||||
};
|
||||
|
||||
trace_bpf_testmod_test_read(current, &ctx);
|
||||
/* This is always true. Use the check to make sure the compiler
|
||||
* doesn't remove bpf_testmod_loop_test.
|
||||
*/
|
||||
if (bpf_testmod_loop_test(101) > 100)
|
||||
trace_bpf_testmod_test_read(current, &ctx);
|
||||
|
||||
/* Magic number to enable writable tp */
|
||||
if (len == 64) {
|
||||
struct bpf_testmod_test_writable_ctx writable = {
|
||||
.val = 1024,
|
||||
};
|
||||
trace_bpf_testmod_test_writable_bare(&writable);
|
||||
if (writable.early_ret)
|
||||
return snprintf(buf, len, "%d\n", writable.val);
|
||||
}
|
||||
|
||||
return -EIO; /* always fail */
|
||||
}
|
||||
|
|
@ -55,13 +89,26 @@ static struct bin_attribute bin_attr_bpf_testmod_file __ro_after_init = {
|
|||
.write = bpf_testmod_test_write,
|
||||
};
|
||||
|
||||
BTF_SET_START(bpf_testmod_kfunc_ids)
|
||||
BTF_ID(func, bpf_testmod_test_mod_kfunc)
|
||||
BTF_SET_END(bpf_testmod_kfunc_ids)
|
||||
|
||||
static DEFINE_KFUNC_BTF_ID_SET(&bpf_testmod_kfunc_ids, bpf_testmod_kfunc_btf_set);
|
||||
|
||||
static int bpf_testmod_init(void)
|
||||
{
|
||||
return sysfs_create_bin_file(kernel_kobj, &bin_attr_bpf_testmod_file);
|
||||
int ret;
|
||||
|
||||
ret = sysfs_create_bin_file(kernel_kobj, &bin_attr_bpf_testmod_file);
|
||||
if (ret)
|
||||
return ret;
|
||||
register_kfunc_btf_id_set(&prog_test_kfunc_list, &bpf_testmod_kfunc_btf_set);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void bpf_testmod_exit(void)
|
||||
{
|
||||
unregister_kfunc_btf_id_set(&prog_test_kfunc_list, &bpf_testmod_kfunc_btf_set);
|
||||
return sysfs_remove_bin_file(kernel_kobj, &bin_attr_bpf_testmod_file);
|
||||
}
|
||||
|
||||
|
|
@ -71,4 +118,3 @@ module_exit(bpf_testmod_exit);
|
|||
MODULE_AUTHOR("Andrii Nakryiko");
|
||||
MODULE_DESCRIPTION("BPF selftests module");
|
||||
MODULE_LICENSE("Dual BSD/GPL");
|
||||
|
||||
|
|
|
|||
|
|
@ -17,4 +17,9 @@ struct bpf_testmod_test_write_ctx {
|
|||
size_t len;
|
||||
};
|
||||
|
||||
struct bpf_testmod_test_writable_ctx {
|
||||
bool early_ret;
|
||||
int val;
|
||||
};
|
||||
|
||||
#endif /* _BPF_TESTMOD_H */
|
||||
|
|
|
|||
|
|
@ -24,11 +24,12 @@ static const char * const btf_kind_str_mapping[] = {
|
|||
[BTF_KIND_VAR] = "VAR",
|
||||
[BTF_KIND_DATASEC] = "DATASEC",
|
||||
[BTF_KIND_FLOAT] = "FLOAT",
|
||||
[BTF_KIND_DECL_TAG] = "DECL_TAG",
|
||||
};
|
||||
|
||||
static const char *btf_kind_str(__u16 kind)
|
||||
{
|
||||
if (kind > BTF_KIND_DATASEC)
|
||||
if (kind > BTF_KIND_DECL_TAG)
|
||||
return "UNKNOWN";
|
||||
return btf_kind_str_mapping[kind];
|
||||
}
|
||||
|
|
@ -177,6 +178,10 @@ int fprintf_btf_type_raw(FILE *out, const struct btf *btf, __u32 id)
|
|||
case BTF_KIND_FLOAT:
|
||||
fprintf(out, " size=%u", t->size);
|
||||
break;
|
||||
case BTF_KIND_DECL_TAG:
|
||||
fprintf(out, " type_id=%u component_idx=%d",
|
||||
t->type, btf_decl_tag(t)->component_idx);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
|
@ -210,7 +215,7 @@ int btf_validate_raw(struct btf *btf, int nr_types, const char *exp_types[])
|
|||
int i;
|
||||
bool ok = true;
|
||||
|
||||
ASSERT_EQ(btf__get_nr_types(btf), nr_types, "btf_nr_types");
|
||||
ASSERT_EQ(btf__type_cnt(btf) - 1, nr_types, "btf_nr_types");
|
||||
|
||||
for (i = 1; i <= nr_types; i++) {
|
||||
if (!ASSERT_STREQ(btf_type_raw_dump(btf, i), exp_types[i - 1], "raw_dump"))
|
||||
|
|
@ -249,7 +254,7 @@ const char *btf_type_c_dump(const struct btf *btf)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
for (i = 1; i <= btf__get_nr_types(btf); i++) {
|
||||
for (i = 1; i < btf__type_cnt(btf); i++) {
|
||||
err = btf_dump__dump_type(d, i);
|
||||
if (err) {
|
||||
fprintf(stderr, "Failed to dump type [%d]: %d\n", i, err);
|
||||
|
|
|
|||
|
|
@ -33,10 +33,9 @@
|
|||
#define CGROUP_MOUNT_DFLT "/sys/fs/cgroup"
|
||||
#define NETCLS_MOUNT_PATH CGROUP_MOUNT_DFLT "/net_cls"
|
||||
#define CGROUP_WORK_DIR "/cgroup-test-work-dir"
|
||||
|
||||
#define format_cgroup_path(buf, path) \
|
||||
snprintf(buf, sizeof(buf), "%s%s%s", CGROUP_MOUNT_PATH, \
|
||||
CGROUP_WORK_DIR, path)
|
||||
snprintf(buf, sizeof(buf), "%s%s%d%s", CGROUP_MOUNT_PATH, \
|
||||
CGROUP_WORK_DIR, getpid(), path)
|
||||
|
||||
#define format_classid_path(buf) \
|
||||
snprintf(buf, sizeof(buf), "%s%s", NETCLS_MOUNT_PATH, \
|
||||
|
|
|
|||
|
|
@ -26,4 +26,4 @@ int join_classid(void);
|
|||
int setup_classid_environment(void);
|
||||
void cleanup_classid_environment(void);
|
||||
|
||||
#endif /* __CGROUP_HELPERS_H */
|
||||
#endif /* __CGROUP_HELPERS_H */
|
||||
|
|
@ -17,7 +17,7 @@
|
|||
const char *cfg_pin_path = "/sys/fs/bpf/flow_dissector";
|
||||
const char *cfg_map_name = "jmp_table";
|
||||
bool cfg_attach = true;
|
||||
char *cfg_section_name;
|
||||
char *cfg_prog_name;
|
||||
char *cfg_path_name;
|
||||
|
||||
static void load_and_attach_program(void)
|
||||
|
|
@ -25,7 +25,11 @@ static void load_and_attach_program(void)
|
|||
int prog_fd, ret;
|
||||
struct bpf_object *obj;
|
||||
|
||||
ret = bpf_flow_load(&obj, cfg_path_name, cfg_section_name,
|
||||
ret = libbpf_set_strict_mode(LIBBPF_STRICT_ALL);
|
||||
if (ret)
|
||||
error(1, 0, "failed to enable libbpf strict mode: %d", ret);
|
||||
|
||||
ret = bpf_flow_load(&obj, cfg_path_name, cfg_prog_name,
|
||||
cfg_map_name, NULL, &prog_fd, NULL);
|
||||
if (ret)
|
||||
error(1, 0, "bpf_flow_load %s", cfg_path_name);
|
||||
|
|
@ -75,15 +79,15 @@ static void parse_opts(int argc, char **argv)
|
|||
break;
|
||||
case 'p':
|
||||
if (cfg_path_name)
|
||||
error(1, 0, "only one prog name can be given");
|
||||
error(1, 0, "only one path can be given");
|
||||
|
||||
cfg_path_name = optarg;
|
||||
break;
|
||||
case 's':
|
||||
if (cfg_section_name)
|
||||
error(1, 0, "only one section can be given");
|
||||
if (cfg_prog_name)
|
||||
error(1, 0, "only one prog can be given");
|
||||
|
||||
cfg_section_name = optarg;
|
||||
cfg_prog_name = optarg;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -94,7 +98,7 @@ static void parse_opts(int argc, char **argv)
|
|||
if (cfg_attach && !cfg_path_name)
|
||||
error(1, 0, "must provide a path to the BPF program");
|
||||
|
||||
if (cfg_attach && !cfg_section_name)
|
||||
if (cfg_attach && !cfg_prog_name)
|
||||
error(1, 0, "must provide a section name");
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
|
||||
static inline int bpf_flow_load(struct bpf_object **obj,
|
||||
const char *path,
|
||||
const char *section_name,
|
||||
const char *prog_name,
|
||||
const char *map_name,
|
||||
const char *keys_map_name,
|
||||
int *prog_fd,
|
||||
|
|
@ -23,13 +23,7 @@ static inline int bpf_flow_load(struct bpf_object **obj,
|
|||
if (ret)
|
||||
return ret;
|
||||
|
||||
main_prog = NULL;
|
||||
bpf_object__for_each_program(prog, *obj) {
|
||||
if (strcmp(section_name, bpf_program__section_name(prog)) == 0) {
|
||||
main_prog = prog;
|
||||
break;
|
||||
}
|
||||
}
|
||||
main_prog = bpf_object__find_program_by_name(*obj, prog_name);
|
||||
if (!main_prog)
|
||||
return -1;
|
||||
|
||||
|
|
|
|||
|
|
@ -4,13 +4,13 @@
|
|||
|
||||
#include "atomics.lskel.h"
|
||||
|
||||
static void test_add(struct atomics *skel)
|
||||
static void test_add(struct atomics_lskel *skel)
|
||||
{
|
||||
int err, prog_fd;
|
||||
__u32 duration = 0, retval;
|
||||
int link_fd;
|
||||
|
||||
link_fd = atomics__add__attach(skel);
|
||||
link_fd = atomics_lskel__add__attach(skel);
|
||||
if (!ASSERT_GT(link_fd, 0, "attach(add)"))
|
||||
return;
|
||||
|
||||
|
|
@ -36,13 +36,13 @@ cleanup:
|
|||
close(link_fd);
|
||||
}
|
||||
|
||||
static void test_sub(struct atomics *skel)
|
||||
static void test_sub(struct atomics_lskel *skel)
|
||||
{
|
||||
int err, prog_fd;
|
||||
__u32 duration = 0, retval;
|
||||
int link_fd;
|
||||
|
||||
link_fd = atomics__sub__attach(skel);
|
||||
link_fd = atomics_lskel__sub__attach(skel);
|
||||
if (!ASSERT_GT(link_fd, 0, "attach(sub)"))
|
||||
return;
|
||||
|
||||
|
|
@ -69,13 +69,13 @@ cleanup:
|
|||
close(link_fd);
|
||||
}
|
||||
|
||||
static void test_and(struct atomics *skel)
|
||||
static void test_and(struct atomics_lskel *skel)
|
||||
{
|
||||
int err, prog_fd;
|
||||
__u32 duration = 0, retval;
|
||||
int link_fd;
|
||||
|
||||
link_fd = atomics__and__attach(skel);
|
||||
link_fd = atomics_lskel__and__attach(skel);
|
||||
if (!ASSERT_GT(link_fd, 0, "attach(and)"))
|
||||
return;
|
||||
|
||||
|
|
@ -97,13 +97,13 @@ cleanup:
|
|||
close(link_fd);
|
||||
}
|
||||
|
||||
static void test_or(struct atomics *skel)
|
||||
static void test_or(struct atomics_lskel *skel)
|
||||
{
|
||||
int err, prog_fd;
|
||||
__u32 duration = 0, retval;
|
||||
int link_fd;
|
||||
|
||||
link_fd = atomics__or__attach(skel);
|
||||
link_fd = atomics_lskel__or__attach(skel);
|
||||
if (!ASSERT_GT(link_fd, 0, "attach(or)"))
|
||||
return;
|
||||
|
||||
|
|
@ -126,13 +126,13 @@ cleanup:
|
|||
close(link_fd);
|
||||
}
|
||||
|
||||
static void test_xor(struct atomics *skel)
|
||||
static void test_xor(struct atomics_lskel *skel)
|
||||
{
|
||||
int err, prog_fd;
|
||||
__u32 duration = 0, retval;
|
||||
int link_fd;
|
||||
|
||||
link_fd = atomics__xor__attach(skel);
|
||||
link_fd = atomics_lskel__xor__attach(skel);
|
||||
if (!ASSERT_GT(link_fd, 0, "attach(xor)"))
|
||||
return;
|
||||
|
||||
|
|
@ -154,13 +154,13 @@ cleanup:
|
|||
close(link_fd);
|
||||
}
|
||||
|
||||
static void test_cmpxchg(struct atomics *skel)
|
||||
static void test_cmpxchg(struct atomics_lskel *skel)
|
||||
{
|
||||
int err, prog_fd;
|
||||
__u32 duration = 0, retval;
|
||||
int link_fd;
|
||||
|
||||
link_fd = atomics__cmpxchg__attach(skel);
|
||||
link_fd = atomics_lskel__cmpxchg__attach(skel);
|
||||
if (!ASSERT_GT(link_fd, 0, "attach(cmpxchg)"))
|
||||
return;
|
||||
|
||||
|
|
@ -183,13 +183,13 @@ cleanup:
|
|||
close(link_fd);
|
||||
}
|
||||
|
||||
static void test_xchg(struct atomics *skel)
|
||||
static void test_xchg(struct atomics_lskel *skel)
|
||||
{
|
||||
int err, prog_fd;
|
||||
__u32 duration = 0, retval;
|
||||
int link_fd;
|
||||
|
||||
link_fd = atomics__xchg__attach(skel);
|
||||
link_fd = atomics_lskel__xchg__attach(skel);
|
||||
if (!ASSERT_GT(link_fd, 0, "attach(xchg)"))
|
||||
return;
|
||||
|
||||
|
|
@ -212,10 +212,10 @@ cleanup:
|
|||
|
||||
void test_atomics(void)
|
||||
{
|
||||
struct atomics *skel;
|
||||
struct atomics_lskel *skel;
|
||||
__u32 duration = 0;
|
||||
|
||||
skel = atomics__open_and_load();
|
||||
skel = atomics_lskel__open_and_load();
|
||||
if (CHECK(!skel, "skel_load", "atomics skeleton failed\n"))
|
||||
return;
|
||||
|
||||
|
|
@ -225,6 +225,7 @@ void test_atomics(void)
|
|||
test__skip();
|
||||
goto cleanup;
|
||||
}
|
||||
skel->bss->pid = getpid();
|
||||
|
||||
if (test__start_subtest("add"))
|
||||
test_add(skel);
|
||||
|
|
@ -242,5 +243,5 @@ void test_atomics(void)
|
|||
test_xchg(skel);
|
||||
|
||||
cleanup:
|
||||
atomics__destroy(skel);
|
||||
atomics_lskel__destroy(skel);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,6 +5,11 @@
|
|||
/* this is how USDT semaphore is actually defined, except volatile modifier */
|
||||
volatile unsigned short uprobe_ref_ctr __attribute__((unused)) __attribute((section(".probes")));
|
||||
|
||||
/* attach point */
|
||||
static void method(void) {
|
||||
return ;
|
||||
}
|
||||
|
||||
void test_attach_probe(void)
|
||||
{
|
||||
DECLARE_LIBBPF_OPTS(bpf_uprobe_opts, uprobe_opts);
|
||||
|
|
@ -14,12 +19,26 @@ void test_attach_probe(void)
|
|||
struct test_attach_probe* skel;
|
||||
size_t uprobe_offset;
|
||||
ssize_t base_addr, ref_ctr_offset;
|
||||
bool legacy;
|
||||
|
||||
/* Check if new-style kprobe/uprobe API is supported.
|
||||
* Kernels that support new FD-based kprobe and uprobe BPF attachment
|
||||
* through perf_event_open() syscall expose
|
||||
* /sys/bus/event_source/devices/kprobe/type and
|
||||
* /sys/bus/event_source/devices/uprobe/type files, respectively. They
|
||||
* contain magic numbers that are passed as "type" field of
|
||||
* perf_event_attr. Lack of such file in the system indicates legacy
|
||||
* kernel with old-style kprobe/uprobe attach interface through
|
||||
* creating per-probe event through tracefs. For such cases
|
||||
* ref_ctr_offset feature is not supported, so we don't test it.
|
||||
*/
|
||||
legacy = access("/sys/bus/event_source/devices/kprobe/type", F_OK) != 0;
|
||||
|
||||
base_addr = get_base_addr();
|
||||
if (CHECK(base_addr < 0, "get_base_addr",
|
||||
"failed to find base addr: %zd", base_addr))
|
||||
return;
|
||||
uprobe_offset = get_uprobe_offset(&get_base_addr, base_addr);
|
||||
uprobe_offset = get_uprobe_offset(&method, base_addr);
|
||||
|
||||
ref_ctr_offset = get_rel_offset((uintptr_t)&uprobe_ref_ctr);
|
||||
if (!ASSERT_GE(ref_ctr_offset, 0, "ref_ctr_offset"))
|
||||
|
|
@ -45,10 +64,11 @@ void test_attach_probe(void)
|
|||
goto cleanup;
|
||||
skel->links.handle_kretprobe = kretprobe_link;
|
||||
|
||||
ASSERT_EQ(uprobe_ref_ctr, 0, "uprobe_ref_ctr_before");
|
||||
if (!legacy)
|
||||
ASSERT_EQ(uprobe_ref_ctr, 0, "uprobe_ref_ctr_before");
|
||||
|
||||
uprobe_opts.retprobe = false;
|
||||
uprobe_opts.ref_ctr_offset = ref_ctr_offset;
|
||||
uprobe_opts.ref_ctr_offset = legacy ? 0 : ref_ctr_offset;
|
||||
uprobe_link = bpf_program__attach_uprobe_opts(skel->progs.handle_uprobe,
|
||||
0 /* self pid */,
|
||||
"/proc/self/exe",
|
||||
|
|
@ -58,11 +78,12 @@ void test_attach_probe(void)
|
|||
goto cleanup;
|
||||
skel->links.handle_uprobe = uprobe_link;
|
||||
|
||||
ASSERT_GT(uprobe_ref_ctr, 0, "uprobe_ref_ctr_after");
|
||||
if (!legacy)
|
||||
ASSERT_GT(uprobe_ref_ctr, 0, "uprobe_ref_ctr_after");
|
||||
|
||||
/* if uprobe uses ref_ctr, uretprobe has to use ref_ctr as well */
|
||||
uprobe_opts.retprobe = true;
|
||||
uprobe_opts.ref_ctr_offset = ref_ctr_offset;
|
||||
uprobe_opts.ref_ctr_offset = legacy ? 0 : ref_ctr_offset;
|
||||
uretprobe_link = bpf_program__attach_uprobe_opts(skel->progs.handle_uretprobe,
|
||||
-1 /* any pid */,
|
||||
"/proc/self/exe",
|
||||
|
|
@ -82,7 +103,7 @@ void test_attach_probe(void)
|
|||
goto cleanup;
|
||||
|
||||
/* trigger & validate uprobe & uretprobe */
|
||||
get_base_addr();
|
||||
method();
|
||||
|
||||
if (CHECK(skel->bss->uprobe_res != 3, "check_uprobe_res",
|
||||
"wrong uprobe res: %d\n", skel->bss->uprobe_res))
|
||||
|
|
|
|||
211
tools/testing/selftests/bpf/prog_tests/bloom_filter_map.c
Normal file
211
tools/testing/selftests/bpf/prog_tests/bloom_filter_map.c
Normal file
|
|
@ -0,0 +1,211 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Copyright (c) 2021 Facebook */
|
||||
|
||||
#include <sys/syscall.h>
|
||||
#include <test_progs.h>
|
||||
#include "bloom_filter_map.skel.h"
|
||||
|
||||
static void test_fail_cases(void)
|
||||
{
|
||||
__u32 value;
|
||||
int fd, err;
|
||||
|
||||
/* Invalid key size */
|
||||
fd = bpf_create_map(BPF_MAP_TYPE_BLOOM_FILTER, 4, sizeof(value), 100, 0);
|
||||
if (!ASSERT_LT(fd, 0, "bpf_create_map bloom filter invalid key size"))
|
||||
close(fd);
|
||||
|
||||
/* Invalid value size */
|
||||
fd = bpf_create_map(BPF_MAP_TYPE_BLOOM_FILTER, 0, 0, 100, 0);
|
||||
if (!ASSERT_LT(fd, 0, "bpf_create_map bloom filter invalid value size 0"))
|
||||
close(fd);
|
||||
|
||||
/* Invalid max entries size */
|
||||
fd = bpf_create_map(BPF_MAP_TYPE_BLOOM_FILTER, 0, sizeof(value), 0, 0);
|
||||
if (!ASSERT_LT(fd, 0, "bpf_create_map bloom filter invalid max entries size"))
|
||||
close(fd);
|
||||
|
||||
/* Bloom filter maps do not support BPF_F_NO_PREALLOC */
|
||||
fd = bpf_create_map(BPF_MAP_TYPE_BLOOM_FILTER, 0, sizeof(value), 100,
|
||||
BPF_F_NO_PREALLOC);
|
||||
if (!ASSERT_LT(fd, 0, "bpf_create_map bloom filter invalid flags"))
|
||||
close(fd);
|
||||
|
||||
fd = bpf_create_map(BPF_MAP_TYPE_BLOOM_FILTER, 0, sizeof(value), 100, 0);
|
||||
if (!ASSERT_GE(fd, 0, "bpf_create_map bloom filter"))
|
||||
return;
|
||||
|
||||
/* Test invalid flags */
|
||||
err = bpf_map_update_elem(fd, NULL, &value, -1);
|
||||
ASSERT_EQ(err, -EINVAL, "bpf_map_update_elem bloom filter invalid flags");
|
||||
|
||||
err = bpf_map_update_elem(fd, NULL, &value, BPF_EXIST);
|
||||
ASSERT_EQ(err, -EINVAL, "bpf_map_update_elem bloom filter invalid flags");
|
||||
|
||||
err = bpf_map_update_elem(fd, NULL, &value, BPF_F_LOCK);
|
||||
ASSERT_EQ(err, -EINVAL, "bpf_map_update_elem bloom filter invalid flags");
|
||||
|
||||
err = bpf_map_update_elem(fd, NULL, &value, BPF_NOEXIST);
|
||||
ASSERT_EQ(err, -EINVAL, "bpf_map_update_elem bloom filter invalid flags");
|
||||
|
||||
err = bpf_map_update_elem(fd, NULL, &value, 10000);
|
||||
ASSERT_EQ(err, -EINVAL, "bpf_map_update_elem bloom filter invalid flags");
|
||||
|
||||
close(fd);
|
||||
}
|
||||
|
||||
static void test_success_cases(void)
|
||||
{
|
||||
char value[11];
|
||||
int fd, err;
|
||||
|
||||
/* Create a map */
|
||||
fd = bpf_create_map(BPF_MAP_TYPE_BLOOM_FILTER, 0, sizeof(value), 100,
|
||||
BPF_F_ZERO_SEED | BPF_F_NUMA_NODE);
|
||||
if (!ASSERT_GE(fd, 0, "bpf_create_map bloom filter success case"))
|
||||
return;
|
||||
|
||||
/* Add a value to the bloom filter */
|
||||
err = bpf_map_update_elem(fd, NULL, &value, 0);
|
||||
if (!ASSERT_OK(err, "bpf_map_update_elem bloom filter success case"))
|
||||
goto done;
|
||||
|
||||
/* Lookup a value in the bloom filter */
|
||||
err = bpf_map_lookup_elem(fd, NULL, &value);
|
||||
ASSERT_OK(err, "bpf_map_update_elem bloom filter success case");
|
||||
|
||||
done:
|
||||
close(fd);
|
||||
}
|
||||
|
||||
static void check_bloom(struct bloom_filter_map *skel)
|
||||
{
|
||||
struct bpf_link *link;
|
||||
|
||||
link = bpf_program__attach(skel->progs.check_bloom);
|
||||
if (!ASSERT_OK_PTR(link, "link"))
|
||||
return;
|
||||
|
||||
syscall(SYS_getpgid);
|
||||
|
||||
ASSERT_EQ(skel->bss->error, 0, "error");
|
||||
|
||||
bpf_link__destroy(link);
|
||||
}
|
||||
|
||||
static void test_inner_map(struct bloom_filter_map *skel, const __u32 *rand_vals,
|
||||
__u32 nr_rand_vals)
|
||||
{
|
||||
int outer_map_fd, inner_map_fd, err, i, key = 0;
|
||||
struct bpf_link *link;
|
||||
|
||||
/* Create a bloom filter map that will be used as the inner map */
|
||||
inner_map_fd = bpf_create_map(BPF_MAP_TYPE_BLOOM_FILTER, 0, sizeof(*rand_vals),
|
||||
nr_rand_vals, 0);
|
||||
if (!ASSERT_GE(inner_map_fd, 0, "bpf_create_map bloom filter inner map"))
|
||||
return;
|
||||
|
||||
for (i = 0; i < nr_rand_vals; i++) {
|
||||
err = bpf_map_update_elem(inner_map_fd, NULL, rand_vals + i, BPF_ANY);
|
||||
if (!ASSERT_OK(err, "Add random value to inner_map_fd"))
|
||||
goto done;
|
||||
}
|
||||
|
||||
/* Add the bloom filter map to the outer map */
|
||||
outer_map_fd = bpf_map__fd(skel->maps.outer_map);
|
||||
err = bpf_map_update_elem(outer_map_fd, &key, &inner_map_fd, BPF_ANY);
|
||||
if (!ASSERT_OK(err, "Add bloom filter map to outer map"))
|
||||
goto done;
|
||||
|
||||
/* Attach the bloom_filter_inner_map prog */
|
||||
link = bpf_program__attach(skel->progs.inner_map);
|
||||
if (!ASSERT_OK_PTR(link, "link"))
|
||||
goto delete_inner_map;
|
||||
|
||||
syscall(SYS_getpgid);
|
||||
|
||||
ASSERT_EQ(skel->bss->error, 0, "error");
|
||||
|
||||
bpf_link__destroy(link);
|
||||
|
||||
delete_inner_map:
|
||||
/* Ensure the inner bloom filter map can be deleted */
|
||||
err = bpf_map_delete_elem(outer_map_fd, &key);
|
||||
ASSERT_OK(err, "Delete inner bloom filter map");
|
||||
|
||||
done:
|
||||
close(inner_map_fd);
|
||||
}
|
||||
|
||||
static int setup_progs(struct bloom_filter_map **out_skel, __u32 **out_rand_vals,
|
||||
__u32 *out_nr_rand_vals)
|
||||
{
|
||||
struct bloom_filter_map *skel;
|
||||
int random_data_fd, bloom_fd;
|
||||
__u32 *rand_vals = NULL;
|
||||
__u32 map_size, val;
|
||||
int err, i;
|
||||
|
||||
/* Set up a bloom filter map skeleton */
|
||||
skel = bloom_filter_map__open_and_load();
|
||||
if (!ASSERT_OK_PTR(skel, "bloom_filter_map__open_and_load"))
|
||||
return -EINVAL;
|
||||
|
||||
/* Set up rand_vals */
|
||||
map_size = bpf_map__max_entries(skel->maps.map_random_data);
|
||||
rand_vals = malloc(sizeof(*rand_vals) * map_size);
|
||||
if (!rand_vals) {
|
||||
err = -ENOMEM;
|
||||
goto error;
|
||||
}
|
||||
|
||||
/* Generate random values and populate both skeletons */
|
||||
random_data_fd = bpf_map__fd(skel->maps.map_random_data);
|
||||
bloom_fd = bpf_map__fd(skel->maps.map_bloom);
|
||||
for (i = 0; i < map_size; i++) {
|
||||
val = rand();
|
||||
|
||||
err = bpf_map_update_elem(random_data_fd, &i, &val, BPF_ANY);
|
||||
if (!ASSERT_OK(err, "Add random value to map_random_data"))
|
||||
goto error;
|
||||
|
||||
err = bpf_map_update_elem(bloom_fd, NULL, &val, BPF_ANY);
|
||||
if (!ASSERT_OK(err, "Add random value to map_bloom"))
|
||||
goto error;
|
||||
|
||||
rand_vals[i] = val;
|
||||
}
|
||||
|
||||
*out_skel = skel;
|
||||
*out_rand_vals = rand_vals;
|
||||
*out_nr_rand_vals = map_size;
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
bloom_filter_map__destroy(skel);
|
||||
if (rand_vals)
|
||||
free(rand_vals);
|
||||
return err;
|
||||
}
|
||||
|
||||
void test_bloom_filter_map(void)
|
||||
{
|
||||
__u32 *rand_vals, nr_rand_vals;
|
||||
struct bloom_filter_map *skel;
|
||||
int err;
|
||||
|
||||
test_fail_cases();
|
||||
test_success_cases();
|
||||
|
||||
err = setup_progs(&skel, &rand_vals, &nr_rand_vals);
|
||||
if (err)
|
||||
return;
|
||||
|
||||
test_inner_map(skel, rand_vals, nr_rand_vals);
|
||||
free(rand_vals);
|
||||
|
||||
check_bloom(skel);
|
||||
|
||||
bloom_filter_map__destroy(skel);
|
||||
}
|
||||
|
|
@ -589,7 +589,7 @@ out:
|
|||
|
||||
static void test_bpf_hash_map(void)
|
||||
{
|
||||
__u32 expected_key_a = 0, expected_key_b = 0, expected_key_c = 0;
|
||||
__u32 expected_key_a = 0, expected_key_b = 0;
|
||||
DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
|
||||
struct bpf_iter_bpf_hash_map *skel;
|
||||
int err, i, len, map_fd, iter_fd;
|
||||
|
|
@ -638,7 +638,6 @@ static void test_bpf_hash_map(void)
|
|||
val = i + 4;
|
||||
expected_key_a += key.a;
|
||||
expected_key_b += key.b;
|
||||
expected_key_c += key.c;
|
||||
expected_val += val;
|
||||
|
||||
err = bpf_map_update_elem(map_fd, &key, &val, BPF_ANY);
|
||||
|
|
@ -685,7 +684,7 @@ out:
|
|||
|
||||
static void test_bpf_percpu_hash_map(void)
|
||||
{
|
||||
__u32 expected_key_a = 0, expected_key_b = 0, expected_key_c = 0;
|
||||
__u32 expected_key_a = 0, expected_key_b = 0;
|
||||
DECLARE_LIBBPF_OPTS(bpf_iter_attach_opts, opts);
|
||||
struct bpf_iter_bpf_percpu_hash_map *skel;
|
||||
int err, i, j, len, map_fd, iter_fd;
|
||||
|
|
@ -722,7 +721,6 @@ static void test_bpf_percpu_hash_map(void)
|
|||
key.c = i + 3;
|
||||
expected_key_a += key.a;
|
||||
expected_key_b += key.b;
|
||||
expected_key_c += key.c;
|
||||
|
||||
for (j = 0; j < bpf_num_possible_cpus(); j++) {
|
||||
*(__u32 *)(val + j * 8) = i + j;
|
||||
|
|
|
|||
|
|
@ -179,7 +179,7 @@ done:
|
|||
free_fds(est_fds, nr_est);
|
||||
}
|
||||
|
||||
void test_bpf_iter_setsockopt(void)
|
||||
void serial_test_bpf_iter_setsockopt(void)
|
||||
{
|
||||
struct bpf_iter_setsockopt *iter_skel = NULL;
|
||||
struct bpf_cubic *cubic_skel = NULL;
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
|
||||
#define nr_iters 2
|
||||
|
||||
void test_bpf_obj_id(void)
|
||||
void serial_test_bpf_obj_id(void)
|
||||
{
|
||||
const __u64 array_magic_value = 0xfaceb00c;
|
||||
const __u32 array_key = 0;
|
||||
|
|
|
|||
|
|
@ -39,82 +39,171 @@ struct scale_test_def {
|
|||
bool fails;
|
||||
};
|
||||
|
||||
void test_bpf_verif_scale(void)
|
||||
static void scale_test(const char *file,
|
||||
enum bpf_prog_type attach_type,
|
||||
bool should_fail)
|
||||
{
|
||||
struct scale_test_def tests[] = {
|
||||
{ "loop3.o", BPF_PROG_TYPE_RAW_TRACEPOINT, true /* fails */ },
|
||||
|
||||
{ "test_verif_scale1.o", BPF_PROG_TYPE_SCHED_CLS },
|
||||
{ "test_verif_scale2.o", BPF_PROG_TYPE_SCHED_CLS },
|
||||
{ "test_verif_scale3.o", BPF_PROG_TYPE_SCHED_CLS },
|
||||
|
||||
{ "pyperf_global.o", BPF_PROG_TYPE_RAW_TRACEPOINT },
|
||||
{ "pyperf_subprogs.o", BPF_PROG_TYPE_RAW_TRACEPOINT },
|
||||
|
||||
/* full unroll by llvm */
|
||||
{ "pyperf50.o", BPF_PROG_TYPE_RAW_TRACEPOINT },
|
||||
{ "pyperf100.o", BPF_PROG_TYPE_RAW_TRACEPOINT },
|
||||
{ "pyperf180.o", BPF_PROG_TYPE_RAW_TRACEPOINT },
|
||||
|
||||
/* partial unroll. llvm will unroll loop ~150 times.
|
||||
* C loop count -> 600.
|
||||
* Asm loop count -> 4.
|
||||
* 16k insns in loop body.
|
||||
* Total of 5 such loops. Total program size ~82k insns.
|
||||
*/
|
||||
{ "pyperf600.o", BPF_PROG_TYPE_RAW_TRACEPOINT },
|
||||
|
||||
/* no unroll at all.
|
||||
* C loop count -> 600.
|
||||
* ASM loop count -> 600.
|
||||
* ~110 insns in loop body.
|
||||
* Total of 5 such loops. Total program size ~1500 insns.
|
||||
*/
|
||||
{ "pyperf600_nounroll.o", BPF_PROG_TYPE_RAW_TRACEPOINT },
|
||||
|
||||
{ "loop1.o", BPF_PROG_TYPE_RAW_TRACEPOINT },
|
||||
{ "loop2.o", BPF_PROG_TYPE_RAW_TRACEPOINT },
|
||||
{ "loop4.o", BPF_PROG_TYPE_SCHED_CLS },
|
||||
{ "loop5.o", BPF_PROG_TYPE_SCHED_CLS },
|
||||
{ "loop6.o", BPF_PROG_TYPE_KPROBE },
|
||||
|
||||
/* partial unroll. 19k insn in a loop.
|
||||
* Total program size 20.8k insn.
|
||||
* ~350k processed_insns
|
||||
*/
|
||||
{ "strobemeta.o", BPF_PROG_TYPE_RAW_TRACEPOINT },
|
||||
|
||||
/* no unroll, tiny loops */
|
||||
{ "strobemeta_nounroll1.o", BPF_PROG_TYPE_RAW_TRACEPOINT },
|
||||
{ "strobemeta_nounroll2.o", BPF_PROG_TYPE_RAW_TRACEPOINT },
|
||||
|
||||
/* non-inlined subprogs */
|
||||
{ "strobemeta_subprogs.o", BPF_PROG_TYPE_RAW_TRACEPOINT },
|
||||
|
||||
{ "test_sysctl_loop1.o", BPF_PROG_TYPE_CGROUP_SYSCTL },
|
||||
{ "test_sysctl_loop2.o", BPF_PROG_TYPE_CGROUP_SYSCTL },
|
||||
|
||||
{ "test_xdp_loop.o", BPF_PROG_TYPE_XDP },
|
||||
{ "test_seg6_loop.o", BPF_PROG_TYPE_LWT_SEG6LOCAL },
|
||||
};
|
||||
libbpf_print_fn_t old_print_fn = NULL;
|
||||
int err, i;
|
||||
int err;
|
||||
|
||||
if (env.verifier_stats) {
|
||||
test__force_log();
|
||||
old_print_fn = libbpf_set_print(libbpf_debug_print);
|
||||
}
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(tests); i++) {
|
||||
const struct scale_test_def *test = &tests[i];
|
||||
|
||||
if (!test__start_subtest(test->file))
|
||||
continue;
|
||||
|
||||
err = check_load(test->file, test->attach_type);
|
||||
CHECK_FAIL(err && !test->fails);
|
||||
}
|
||||
err = check_load(file, attach_type);
|
||||
if (should_fail)
|
||||
ASSERT_ERR(err, "expect_error");
|
||||
else
|
||||
ASSERT_OK(err, "expect_success");
|
||||
|
||||
if (env.verifier_stats)
|
||||
libbpf_set_print(old_print_fn);
|
||||
}
|
||||
|
||||
void test_verif_scale1()
|
||||
{
|
||||
scale_test("test_verif_scale1.o", BPF_PROG_TYPE_SCHED_CLS, false);
|
||||
}
|
||||
|
||||
void test_verif_scale2()
|
||||
{
|
||||
scale_test("test_verif_scale2.o", BPF_PROG_TYPE_SCHED_CLS, false);
|
||||
}
|
||||
|
||||
void test_verif_scale3()
|
||||
{
|
||||
scale_test("test_verif_scale3.o", BPF_PROG_TYPE_SCHED_CLS, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_pyperf_global()
|
||||
{
|
||||
scale_test("pyperf_global.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_pyperf_subprogs()
|
||||
{
|
||||
scale_test("pyperf_subprogs.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_pyperf50()
|
||||
{
|
||||
/* full unroll by llvm */
|
||||
scale_test("pyperf50.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_pyperf100()
|
||||
{
|
||||
/* full unroll by llvm */
|
||||
scale_test("pyperf100.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_pyperf180()
|
||||
{
|
||||
/* full unroll by llvm */
|
||||
scale_test("pyperf180.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_pyperf600()
|
||||
{
|
||||
/* partial unroll. llvm will unroll loop ~150 times.
|
||||
* C loop count -> 600.
|
||||
* Asm loop count -> 4.
|
||||
* 16k insns in loop body.
|
||||
* Total of 5 such loops. Total program size ~82k insns.
|
||||
*/
|
||||
scale_test("pyperf600.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_pyperf600_nounroll()
|
||||
{
|
||||
/* no unroll at all.
|
||||
* C loop count -> 600.
|
||||
* ASM loop count -> 600.
|
||||
* ~110 insns in loop body.
|
||||
* Total of 5 such loops. Total program size ~1500 insns.
|
||||
*/
|
||||
scale_test("pyperf600_nounroll.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_loop1()
|
||||
{
|
||||
scale_test("loop1.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_loop2()
|
||||
{
|
||||
scale_test("loop2.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_loop3_fail()
|
||||
{
|
||||
scale_test("loop3.o", BPF_PROG_TYPE_RAW_TRACEPOINT, true /* fails */);
|
||||
}
|
||||
|
||||
void test_verif_scale_loop4()
|
||||
{
|
||||
scale_test("loop4.o", BPF_PROG_TYPE_SCHED_CLS, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_loop5()
|
||||
{
|
||||
scale_test("loop5.o", BPF_PROG_TYPE_SCHED_CLS, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_loop6()
|
||||
{
|
||||
scale_test("loop6.o", BPF_PROG_TYPE_KPROBE, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_strobemeta()
|
||||
{
|
||||
/* partial unroll. 19k insn in a loop.
|
||||
* Total program size 20.8k insn.
|
||||
* ~350k processed_insns
|
||||
*/
|
||||
scale_test("strobemeta.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_strobemeta_nounroll1()
|
||||
{
|
||||
/* no unroll, tiny loops */
|
||||
scale_test("strobemeta_nounroll1.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_strobemeta_nounroll2()
|
||||
{
|
||||
/* no unroll, tiny loops */
|
||||
scale_test("strobemeta_nounroll2.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_strobemeta_subprogs()
|
||||
{
|
||||
/* non-inlined subprogs */
|
||||
scale_test("strobemeta_subprogs.o", BPF_PROG_TYPE_RAW_TRACEPOINT, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_sysctl_loop1()
|
||||
{
|
||||
scale_test("test_sysctl_loop1.o", BPF_PROG_TYPE_CGROUP_SYSCTL, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_sysctl_loop2()
|
||||
{
|
||||
scale_test("test_sysctl_loop2.o", BPF_PROG_TYPE_CGROUP_SYSCTL, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_xdp_loop()
|
||||
{
|
||||
scale_test("test_xdp_loop.o", BPF_PROG_TYPE_XDP, false);
|
||||
}
|
||||
|
||||
void test_verif_scale_seg6_loop()
|
||||
{
|
||||
scale_test("test_seg6_loop.o", BPF_PROG_TYPE_LWT_SEG6LOCAL, false);
|
||||
}
|
||||
|
||||
void test_verif_twfw()
|
||||
{
|
||||
scale_test("twfw.o", BPF_PROG_TYPE_CGROUP_SKB, false);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -39,8 +39,8 @@ static bool always_log;
|
|||
#define BTF_END_RAW 0xdeadbeef
|
||||
#define NAME_TBD 0xdeadb33f
|
||||
|
||||
#define NAME_NTH(N) (0xffff0000 | N)
|
||||
#define IS_NAME_NTH(X) ((X & 0xffff0000) == 0xffff0000)
|
||||
#define NAME_NTH(N) (0xfffe0000 | N)
|
||||
#define IS_NAME_NTH(X) ((X & 0xffff0000) == 0xfffe0000)
|
||||
#define GET_NAME_NTH_IDX(X) (X & 0x0000ffff)
|
||||
|
||||
#define MAX_NR_RAW_U32 1024
|
||||
|
|
@ -3661,6 +3661,285 @@ static struct btf_raw_test raw_tests[] = {
|
|||
.err_str = "Invalid type_size",
|
||||
},
|
||||
|
||||
{
|
||||
.descr = "decl_tag test #1, struct/member, well-formed",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_STRUCT_ENC(0, 2, 8), /* [2] */
|
||||
BTF_MEMBER_ENC(NAME_TBD, 1, 0),
|
||||
BTF_MEMBER_ENC(NAME_TBD, 1, 32),
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 2, -1),
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 2, 0),
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 2, 1),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0m1\0m2\0tag1\0tag2\0tag3"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 8,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 2,
|
||||
.max_entries = 1,
|
||||
},
|
||||
{
|
||||
.descr = "decl_tag test #2, union/member, well-formed",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_UNION_ENC(NAME_TBD, 2, 4), /* [2] */
|
||||
BTF_MEMBER_ENC(NAME_TBD, 1, 0),
|
||||
BTF_MEMBER_ENC(NAME_TBD, 1, 0),
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 2, -1),
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 2, 0),
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 2, 1),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0t\0m1\0m2\0tag1\0tag2\0tag3"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 2,
|
||||
.max_entries = 1,
|
||||
},
|
||||
{
|
||||
.descr = "decl_tag test #3, variable, well-formed",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
|
||||
BTF_VAR_ENC(NAME_TBD, 1, 1), /* [3] */
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 2, -1),
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 3, -1),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0local\0global\0tag1\0tag2"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
},
|
||||
{
|
||||
.descr = "decl_tag test #4, func/parameter, well-formed",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_FUNC_PROTO_ENC(0, 2), /* [2] */
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
|
||||
BTF_FUNC_ENC(NAME_TBD, 2), /* [3] */
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 3, -1),
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 3, 0),
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 3, 1),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0arg1\0arg2\0f\0tag1\0tag2\0tag3"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
},
|
||||
{
|
||||
.descr = "decl_tag test #5, invalid value",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
|
||||
BTF_DECL_TAG_ENC(0, 2, -1),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0local\0tag"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
.btf_load_err = true,
|
||||
.err_str = "Invalid value",
|
||||
},
|
||||
{
|
||||
.descr = "decl_tag test #6, invalid target type",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 1, -1),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0tag1"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
.btf_load_err = true,
|
||||
.err_str = "Invalid type",
|
||||
},
|
||||
{
|
||||
.descr = "decl_tag test #7, invalid vlen",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
|
||||
BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DECL_TAG, 0, 1), 2), (0),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0local\0tag1"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
.btf_load_err = true,
|
||||
.err_str = "vlen != 0",
|
||||
},
|
||||
{
|
||||
.descr = "decl_tag test #8, invalid kflag",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
|
||||
BTF_TYPE_ENC(NAME_TBD, BTF_INFO_ENC(BTF_KIND_DECL_TAG, 1, 0), 2), (-1),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0local\0tag1"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
.btf_load_err = true,
|
||||
.err_str = "Invalid btf_info kind_flag",
|
||||
},
|
||||
{
|
||||
.descr = "decl_tag test #9, var, invalid component_idx",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_VAR_ENC(NAME_TBD, 1, 0), /* [2] */
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 2, 0),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0local\0tag"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
.btf_load_err = true,
|
||||
.err_str = "Invalid component_idx",
|
||||
},
|
||||
{
|
||||
.descr = "decl_tag test #10, struct member, invalid component_idx",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_STRUCT_ENC(0, 2, 8), /* [2] */
|
||||
BTF_MEMBER_ENC(NAME_TBD, 1, 0),
|
||||
BTF_MEMBER_ENC(NAME_TBD, 1, 32),
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 2, 2),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0m1\0m2\0tag"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 8,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 2,
|
||||
.max_entries = 1,
|
||||
.btf_load_err = true,
|
||||
.err_str = "Invalid component_idx",
|
||||
},
|
||||
{
|
||||
.descr = "decl_tag test #11, func parameter, invalid component_idx",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_FUNC_PROTO_ENC(0, 2), /* [2] */
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
|
||||
BTF_FUNC_ENC(NAME_TBD, 2), /* [3] */
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 3, 2),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0arg1\0arg2\0f\0tag"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
.btf_load_err = true,
|
||||
.err_str = "Invalid component_idx",
|
||||
},
|
||||
{
|
||||
.descr = "decl_tag test #12, < -1 component_idx",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_FUNC_PROTO_ENC(0, 2), /* [2] */
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
|
||||
BTF_FUNC_ENC(NAME_TBD, 2), /* [3] */
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 3, -2),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0arg1\0arg2\0f\0tag"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
.btf_load_err = true,
|
||||
.err_str = "Invalid component_idx",
|
||||
},
|
||||
{
|
||||
.descr = "decl_tag test #13, typedef, well-formed",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_TYPEDEF_ENC(NAME_TBD, 1), /* [2] */
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 2, -1),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0t\0tag"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
},
|
||||
{
|
||||
.descr = "decl_tag test #14, typedef, invalid component_idx",
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_TYPEDEF_ENC(NAME_TBD, 1), /* [2] */
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 2, 0),
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0local\0tag"),
|
||||
.map_type = BPF_MAP_TYPE_ARRAY,
|
||||
.map_name = "tag_type_check_btf",
|
||||
.key_size = sizeof(int),
|
||||
.value_size = 4,
|
||||
.key_type_id = 1,
|
||||
.value_type_id = 1,
|
||||
.max_entries = 1,
|
||||
.btf_load_err = true,
|
||||
.err_str = "Invalid component_idx",
|
||||
},
|
||||
|
||||
}; /* struct btf_raw_test raw_tests[] */
|
||||
|
||||
static const char *get_next_str(const char *start, const char *end)
|
||||
|
|
@ -4268,7 +4547,7 @@ static void do_test_file(unsigned int test_num)
|
|||
if (CHECK(err, "obj: %d", err))
|
||||
return;
|
||||
|
||||
prog = bpf_program__next(NULL, obj);
|
||||
prog = bpf_object__next_program(obj, NULL);
|
||||
if (CHECK(!prog, "Cannot find bpf_prog")) {
|
||||
err = -1;
|
||||
goto done;
|
||||
|
|
@ -6421,27 +6700,33 @@ const struct btf_dedup_test dedup_tests[] = {
|
|||
BTF_MEMBER_ENC(NAME_NTH(4), 5, 64), /* const int *a; */
|
||||
BTF_MEMBER_ENC(NAME_NTH(5), 2, 128), /* int b[16]; */
|
||||
BTF_MEMBER_ENC(NAME_NTH(6), 1, 640), /* int c; */
|
||||
BTF_MEMBER_ENC(NAME_NTH(8), 13, 672), /* float d; */
|
||||
BTF_MEMBER_ENC(NAME_NTH(8), 15, 672), /* float d; */
|
||||
/* ptr -> [3] struct s */
|
||||
BTF_PTR_ENC(3), /* [4] */
|
||||
/* ptr -> [6] const int */
|
||||
BTF_PTR_ENC(6), /* [5] */
|
||||
/* const -> [1] int */
|
||||
BTF_CONST_ENC(1), /* [6] */
|
||||
/* tag -> [3] struct s */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(2), 3, -1), /* [7] */
|
||||
/* tag -> [3] struct s, member 1 */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(2), 3, 1), /* [8] */
|
||||
|
||||
/* full copy of the above */
|
||||
BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4), /* [7] */
|
||||
BTF_TYPE_ARRAY_ENC(7, 7, 16), /* [8] */
|
||||
BTF_STRUCT_ENC(NAME_NTH(2), 5, 88), /* [9] */
|
||||
BTF_MEMBER_ENC(NAME_NTH(3), 10, 0),
|
||||
BTF_MEMBER_ENC(NAME_NTH(4), 11, 64),
|
||||
BTF_MEMBER_ENC(NAME_NTH(5), 8, 128),
|
||||
BTF_MEMBER_ENC(NAME_NTH(6), 7, 640),
|
||||
BTF_MEMBER_ENC(NAME_NTH(8), 13, 672),
|
||||
BTF_PTR_ENC(9), /* [10] */
|
||||
BTF_PTR_ENC(12), /* [11] */
|
||||
BTF_CONST_ENC(7), /* [12] */
|
||||
BTF_TYPE_FLOAT_ENC(NAME_NTH(7), 4), /* [13] */
|
||||
BTF_TYPE_INT_ENC(NAME_NTH(1), BTF_INT_SIGNED, 0, 32, 4), /* [9] */
|
||||
BTF_TYPE_ARRAY_ENC(9, 9, 16), /* [10] */
|
||||
BTF_STRUCT_ENC(NAME_NTH(2), 5, 88), /* [11] */
|
||||
BTF_MEMBER_ENC(NAME_NTH(3), 12, 0),
|
||||
BTF_MEMBER_ENC(NAME_NTH(4), 13, 64),
|
||||
BTF_MEMBER_ENC(NAME_NTH(5), 10, 128),
|
||||
BTF_MEMBER_ENC(NAME_NTH(6), 9, 640),
|
||||
BTF_MEMBER_ENC(NAME_NTH(8), 15, 672),
|
||||
BTF_PTR_ENC(11), /* [12] */
|
||||
BTF_PTR_ENC(14), /* [13] */
|
||||
BTF_CONST_ENC(9), /* [14] */
|
||||
BTF_TYPE_FLOAT_ENC(NAME_NTH(7), 4), /* [15] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(2), 11, -1), /* [16] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(2), 11, 1), /* [17] */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0int\0s\0next\0a\0b\0c\0float\0d"),
|
||||
|
|
@ -6458,14 +6743,16 @@ const struct btf_dedup_test dedup_tests[] = {
|
|||
BTF_MEMBER_ENC(NAME_NTH(1), 5, 64), /* const int *a; */
|
||||
BTF_MEMBER_ENC(NAME_NTH(2), 2, 128), /* int b[16]; */
|
||||
BTF_MEMBER_ENC(NAME_NTH(3), 1, 640), /* int c; */
|
||||
BTF_MEMBER_ENC(NAME_NTH(4), 7, 672), /* float d; */
|
||||
BTF_MEMBER_ENC(NAME_NTH(4), 9, 672), /* float d; */
|
||||
/* ptr -> [3] struct s */
|
||||
BTF_PTR_ENC(3), /* [4] */
|
||||
/* ptr -> [6] const int */
|
||||
BTF_PTR_ENC(6), /* [5] */
|
||||
/* const -> [1] int */
|
||||
BTF_CONST_ENC(1), /* [6] */
|
||||
BTF_TYPE_FLOAT_ENC(NAME_NTH(7), 4), /* [7] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(2), 3, -1), /* [7] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(2), 3, 1), /* [8] */
|
||||
BTF_TYPE_FLOAT_ENC(NAME_NTH(7), 4), /* [9] */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0a\0b\0c\0d\0int\0float\0next\0s"),
|
||||
|
|
@ -6590,9 +6877,12 @@ const struct btf_dedup_test dedup_tests[] = {
|
|||
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 8),
|
||||
BTF_FUNC_ENC(NAME_TBD, 12), /* [13] func */
|
||||
BTF_TYPE_FLOAT_ENC(NAME_TBD, 2), /* [14] float */
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 13, -1), /* [15] decl_tag */
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 13, 1), /* [16] decl_tag */
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 7, -1), /* [17] decl_tag */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N"),
|
||||
BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P\0Q"),
|
||||
},
|
||||
.expect = {
|
||||
.raw_types = {
|
||||
|
|
@ -6616,9 +6906,12 @@ const struct btf_dedup_test dedup_tests[] = {
|
|||
BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 8),
|
||||
BTF_FUNC_ENC(NAME_TBD, 12), /* [13] func */
|
||||
BTF_TYPE_FLOAT_ENC(NAME_TBD, 2), /* [14] float */
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 13, -1), /* [15] decl_tag */
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 13, 1), /* [16] decl_tag */
|
||||
BTF_DECL_TAG_ENC(NAME_TBD, 7, -1), /* [17] decl_tag */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N"),
|
||||
BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P\0Q"),
|
||||
},
|
||||
.opts = {
|
||||
.dont_resolve_fwds = false,
|
||||
|
|
@ -6767,6 +7060,185 @@ const struct btf_dedup_test dedup_tests[] = {
|
|||
.dedup_table_size = 1
|
||||
},
|
||||
},
|
||||
{
|
||||
.descr = "dedup: func/func_arg/var tags",
|
||||
.input = {
|
||||
.raw_types = {
|
||||
/* int */
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
/* static int t */
|
||||
BTF_VAR_ENC(NAME_NTH(1), 1, 0), /* [2] */
|
||||
/* void f(int a1, int a2) */
|
||||
BTF_FUNC_PROTO_ENC(0, 2), /* [3] */
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(3), 1),
|
||||
BTF_FUNC_ENC(NAME_NTH(4), 2), /* [4] */
|
||||
/* tag -> t */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(5), 2, -1), /* [5] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(5), 2, -1), /* [6] */
|
||||
/* tag -> func */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(5), 4, -1), /* [7] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(5), 4, -1), /* [8] */
|
||||
/* tag -> func arg a1 */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(5), 4, 1), /* [9] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(5), 4, 1), /* [10] */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0t\0a1\0a2\0f\0tag"),
|
||||
},
|
||||
.expect = {
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_VAR_ENC(NAME_NTH(1), 1, 0), /* [2] */
|
||||
BTF_FUNC_PROTO_ENC(0, 2), /* [3] */
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(3), 1),
|
||||
BTF_FUNC_ENC(NAME_NTH(4), 2), /* [4] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(5), 2, -1), /* [5] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(5), 4, -1), /* [6] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(5), 4, 1), /* [7] */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0t\0a1\0a2\0f\0tag"),
|
||||
},
|
||||
.opts = {
|
||||
.dont_resolve_fwds = false,
|
||||
},
|
||||
},
|
||||
{
|
||||
.descr = "dedup: func/func_param tags",
|
||||
.input = {
|
||||
.raw_types = {
|
||||
/* int */
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
/* void f(int a1, int a2) */
|
||||
BTF_FUNC_PROTO_ENC(0, 2), /* [2] */
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(1), 1),
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
|
||||
BTF_FUNC_ENC(NAME_NTH(3), 2), /* [3] */
|
||||
/* void f(int a1, int a2) */
|
||||
BTF_FUNC_PROTO_ENC(0, 2), /* [4] */
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(1), 1),
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
|
||||
BTF_FUNC_ENC(NAME_NTH(3), 4), /* [5] */
|
||||
/* tag -> f: tag1, tag2 */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(4), 3, -1), /* [6] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(5), 3, -1), /* [7] */
|
||||
/* tag -> f/a2: tag1, tag2 */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(4), 3, 1), /* [8] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(5), 3, 1), /* [9] */
|
||||
/* tag -> f: tag1, tag3 */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(4), 5, -1), /* [10] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(6), 5, -1), /* [11] */
|
||||
/* tag -> f/a2: tag1, tag3 */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(4), 5, 1), /* [12] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(6), 5, 1), /* [13] */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0a1\0a2\0f\0tag1\0tag2\0tag3"),
|
||||
},
|
||||
.expect = {
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_FUNC_PROTO_ENC(0, 2), /* [2] */
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(1), 1),
|
||||
BTF_FUNC_PROTO_ARG_ENC(NAME_NTH(2), 1),
|
||||
BTF_FUNC_ENC(NAME_NTH(3), 2), /* [3] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(4), 3, -1), /* [4] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(5), 3, -1), /* [5] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(6), 3, -1), /* [6] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(4), 3, 1), /* [7] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(5), 3, 1), /* [8] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(6), 3, 1), /* [9] */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0a1\0a2\0f\0tag1\0tag2\0tag3"),
|
||||
},
|
||||
.opts = {
|
||||
.dont_resolve_fwds = false,
|
||||
},
|
||||
},
|
||||
{
|
||||
.descr = "dedup: struct/struct_member tags",
|
||||
.input = {
|
||||
.raw_types = {
|
||||
/* int */
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_STRUCT_ENC(NAME_NTH(1), 2, 8), /* [2] */
|
||||
BTF_MEMBER_ENC(NAME_NTH(2), 1, 0),
|
||||
BTF_MEMBER_ENC(NAME_NTH(3), 1, 32),
|
||||
BTF_STRUCT_ENC(NAME_NTH(1), 2, 8), /* [3] */
|
||||
BTF_MEMBER_ENC(NAME_NTH(2), 1, 0),
|
||||
BTF_MEMBER_ENC(NAME_NTH(3), 1, 32),
|
||||
/* tag -> t: tag1, tag2 */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(4), 2, -1), /* [4] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(5), 2, -1), /* [5] */
|
||||
/* tag -> t/m2: tag1, tag2 */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(4), 2, 1), /* [6] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(5), 2, 1), /* [7] */
|
||||
/* tag -> t: tag1, tag3 */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(4), 3, -1), /* [8] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(6), 3, -1), /* [9] */
|
||||
/* tag -> t/m2: tag1, tag3 */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(4), 3, 1), /* [10] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(6), 3, 1), /* [11] */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0t\0m1\0m2\0tag1\0tag2\0tag3"),
|
||||
},
|
||||
.expect = {
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_STRUCT_ENC(NAME_NTH(1), 2, 8), /* [2] */
|
||||
BTF_MEMBER_ENC(NAME_NTH(2), 1, 0),
|
||||
BTF_MEMBER_ENC(NAME_NTH(3), 1, 32),
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(4), 2, -1), /* [3] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(5), 2, -1), /* [4] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(6), 2, -1), /* [5] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(4), 2, 1), /* [6] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(5), 2, 1), /* [7] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(6), 2, 1), /* [8] */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0t\0m1\0m2\0tag1\0tag2\0tag3"),
|
||||
},
|
||||
.opts = {
|
||||
.dont_resolve_fwds = false,
|
||||
},
|
||||
},
|
||||
{
|
||||
.descr = "dedup: typedef tags",
|
||||
.input = {
|
||||
.raw_types = {
|
||||
/* int */
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_TYPEDEF_ENC(NAME_NTH(1), 1), /* [2] */
|
||||
BTF_TYPEDEF_ENC(NAME_NTH(1), 1), /* [3] */
|
||||
/* tag -> t: tag1, tag2 */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(2), 2, -1), /* [4] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(3), 2, -1), /* [5] */
|
||||
/* tag -> t: tag1, tag3 */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(2), 3, -1), /* [6] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(4), 3, -1), /* [7] */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0t\0tag1\0tag2\0tag3"),
|
||||
},
|
||||
.expect = {
|
||||
.raw_types = {
|
||||
BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */
|
||||
BTF_TYPEDEF_ENC(NAME_NTH(1), 1), /* [2] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(2), 2, -1), /* [3] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(3), 2, -1), /* [4] */
|
||||
BTF_DECL_TAG_ENC(NAME_NTH(4), 2, -1), /* [5] */
|
||||
BTF_END_RAW,
|
||||
},
|
||||
BTF_STR_SEC("\0t\0tag1\0tag2\0tag3"),
|
||||
},
|
||||
.opts = {
|
||||
.dont_resolve_fwds = false,
|
||||
},
|
||||
},
|
||||
|
||||
};
|
||||
|
||||
|
|
@ -6801,6 +7273,8 @@ static int btf_type_size(const struct btf_type *t)
|
|||
return base_size + sizeof(struct btf_var);
|
||||
case BTF_KIND_DATASEC:
|
||||
return base_size + vlen * sizeof(struct btf_var_secinfo);
|
||||
case BTF_KIND_DECL_TAG:
|
||||
return base_size + sizeof(struct btf_decl_tag);
|
||||
default:
|
||||
fprintf(stderr, "Unsupported BTF_KIND:%u\n", kind);
|
||||
return -EINVAL;
|
||||
|
|
@ -6871,8 +7345,8 @@ static void do_test_dedup(unsigned int test_num)
|
|||
goto done;
|
||||
}
|
||||
|
||||
test_btf_data = btf__get_raw_data(test_btf, &test_btf_size);
|
||||
expect_btf_data = btf__get_raw_data(expect_btf, &expect_btf_size);
|
||||
test_btf_data = btf__raw_data(test_btf, &test_btf_size);
|
||||
expect_btf_data = btf__raw_data(expect_btf, &expect_btf_size);
|
||||
if (CHECK(test_btf_size != expect_btf_size,
|
||||
"test_btf_size:%u != expect_btf_size:%u",
|
||||
test_btf_size, expect_btf_size)) {
|
||||
|
|
@ -6926,8 +7400,8 @@ static void do_test_dedup(unsigned int test_num)
|
|||
expect_str_cur += expect_len + 1;
|
||||
}
|
||||
|
||||
test_nr_types = btf__get_nr_types(test_btf);
|
||||
expect_nr_types = btf__get_nr_types(expect_btf);
|
||||
test_nr_types = btf__type_cnt(test_btf);
|
||||
expect_nr_types = btf__type_cnt(expect_btf);
|
||||
if (CHECK(test_nr_types != expect_nr_types,
|
||||
"test_nr_types:%u != expect_nr_types:%u",
|
||||
test_nr_types, expect_nr_types)) {
|
||||
|
|
@ -6935,7 +7409,7 @@ static void do_test_dedup(unsigned int test_num)
|
|||
goto done;
|
||||
}
|
||||
|
||||
for (i = 1; i <= test_nr_types; i++) {
|
||||
for (i = 1; i < test_nr_types; i++) {
|
||||
const struct btf_type *test_type, *expect_type;
|
||||
int test_size, expect_size;
|
||||
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ static struct btf_dump_test_case {
|
|||
static int btf_dump_all_types(const struct btf *btf,
|
||||
const struct btf_dump_opts *opts)
|
||||
{
|
||||
size_t type_cnt = btf__get_nr_types(btf);
|
||||
size_t type_cnt = btf__type_cnt(btf);
|
||||
struct btf_dump *d;
|
||||
int err = 0, id;
|
||||
|
||||
|
|
@ -36,7 +36,7 @@ static int btf_dump_all_types(const struct btf *btf,
|
|||
if (err)
|
||||
return err;
|
||||
|
||||
for (id = 1; id <= type_cnt; id++) {
|
||||
for (id = 1; id < type_cnt; id++) {
|
||||
err = btf_dump__dump_type(d, id);
|
||||
if (err)
|
||||
goto done;
|
||||
|
|
@ -133,7 +133,7 @@ static char *dump_buf;
|
|||
static size_t dump_buf_sz;
|
||||
static FILE *dump_buf_file;
|
||||
|
||||
void test_btf_dump_incremental(void)
|
||||
static void test_btf_dump_incremental(void)
|
||||
{
|
||||
struct btf *btf = NULL;
|
||||
struct btf_dump *d = NULL;
|
||||
|
|
@ -171,7 +171,7 @@ void test_btf_dump_incremental(void)
|
|||
err = btf__add_field(btf, "x", 2, 0, 0);
|
||||
ASSERT_OK(err, "field_ok");
|
||||
|
||||
for (i = 1; i <= btf__get_nr_types(btf); i++) {
|
||||
for (i = 1; i < btf__type_cnt(btf); i++) {
|
||||
err = btf_dump__dump_type(d, i);
|
||||
ASSERT_OK(err, "dump_type_ok");
|
||||
}
|
||||
|
|
@ -210,7 +210,7 @@ void test_btf_dump_incremental(void)
|
|||
err = btf__add_field(btf, "s", 3, 32, 0);
|
||||
ASSERT_OK(err, "field_ok");
|
||||
|
||||
for (i = 1; i <= btf__get_nr_types(btf); i++) {
|
||||
for (i = 1; i < btf__type_cnt(btf); i++) {
|
||||
err = btf_dump__dump_type(d, i);
|
||||
ASSERT_OK(err, "dump_type_ok");
|
||||
}
|
||||
|
|
@ -358,12 +358,27 @@ static void test_btf_dump_int_data(struct btf *btf, struct btf_dump *d,
|
|||
TEST_BTF_DUMP_DATA_OVER(btf, d, NULL, str, int, sizeof(int)-1, "", 1);
|
||||
|
||||
#ifdef __SIZEOF_INT128__
|
||||
TEST_BTF_DUMP_DATA(btf, d, NULL, str, __int128, BTF_F_COMPACT,
|
||||
"(__int128)0xffffffffffffffff",
|
||||
0xffffffffffffffff);
|
||||
ASSERT_OK(btf_dump_data(btf, d, "__int128", NULL, 0, &i, 16, str,
|
||||
"(__int128)0xfffffffffffffffffffffffffffffffe"),
|
||||
"dump __int128");
|
||||
/* gcc encode unsigned __int128 type with name "__int128 unsigned" in dwarf,
|
||||
* and clang encode it with name "unsigned __int128" in dwarf.
|
||||
* Do an availability test for either variant before doing actual test.
|
||||
*/
|
||||
if (btf__find_by_name(btf, "unsigned __int128") > 0) {
|
||||
TEST_BTF_DUMP_DATA(btf, d, NULL, str, unsigned __int128, BTF_F_COMPACT,
|
||||
"(unsigned __int128)0xffffffffffffffff",
|
||||
0xffffffffffffffff);
|
||||
ASSERT_OK(btf_dump_data(btf, d, "unsigned __int128", NULL, 0, &i, 16, str,
|
||||
"(unsigned __int128)0xfffffffffffffffffffffffffffffffe"),
|
||||
"dump unsigned __int128");
|
||||
} else if (btf__find_by_name(btf, "__int128 unsigned") > 0) {
|
||||
TEST_BTF_DUMP_DATA(btf, d, NULL, str, __int128 unsigned, BTF_F_COMPACT,
|
||||
"(__int128 unsigned)0xffffffffffffffff",
|
||||
0xffffffffffffffff);
|
||||
ASSERT_OK(btf_dump_data(btf, d, "__int128 unsigned", NULL, 0, &i, 16, str,
|
||||
"(__int128 unsigned)0xfffffffffffffffffffffffffffffffe"),
|
||||
"dump unsigned __int128");
|
||||
} else {
|
||||
ASSERT_TRUE(false, "unsigned_int128_not_found");
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
@ -763,8 +778,10 @@ static void test_btf_dump_struct_data(struct btf *btf, struct btf_dump *d,
|
|||
static void test_btf_dump_var_data(struct btf *btf, struct btf_dump *d,
|
||||
char *str)
|
||||
{
|
||||
#if defined(__i386__) || defined(__x86_64__) || defined(__aarch64__)
|
||||
TEST_BTF_DUMP_VAR(btf, d, NULL, str, "cpu_number", int, BTF_F_COMPACT,
|
||||
"int cpu_number = (int)100", 100);
|
||||
#endif
|
||||
TEST_BTF_DUMP_VAR(btf, d, NULL, str, "cpu_profile_flip", int, BTF_F_COMPACT,
|
||||
"static int cpu_profile_flip = (int)2", 2);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,12 +7,12 @@
|
|||
#include <bpf/btf.h>
|
||||
|
||||
void test_btf_endian() {
|
||||
#if __BYTE_ORDER == __LITTLE_ENDIAN
|
||||
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
|
||||
enum btf_endianness endian = BTF_LITTLE_ENDIAN;
|
||||
#elif __BYTE_ORDER == __BIG_ENDIAN
|
||||
#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
|
||||
enum btf_endianness endian = BTF_BIG_ENDIAN;
|
||||
#else
|
||||
#error "Unrecognized __BYTE_ORDER"
|
||||
#error "Unrecognized __BYTE_ORDER__"
|
||||
#endif
|
||||
enum btf_endianness swap_endian = 1 - endian;
|
||||
struct btf *btf = NULL, *swap_btf = NULL;
|
||||
|
|
@ -32,7 +32,7 @@ void test_btf_endian() {
|
|||
ASSERT_EQ(btf__endianness(btf), swap_endian, "endian");
|
||||
|
||||
/* Get raw BTF data in non-native endianness... */
|
||||
raw_data = btf__get_raw_data(btf, &raw_sz);
|
||||
raw_data = btf__raw_data(btf, &raw_sz);
|
||||
if (!ASSERT_OK_PTR(raw_data, "raw_data_inverted"))
|
||||
goto err_out;
|
||||
|
||||
|
|
@ -42,9 +42,9 @@ void test_btf_endian() {
|
|||
goto err_out;
|
||||
|
||||
ASSERT_EQ(btf__endianness(swap_btf), swap_endian, "endian");
|
||||
ASSERT_EQ(btf__get_nr_types(swap_btf), btf__get_nr_types(btf), "nr_types");
|
||||
ASSERT_EQ(btf__type_cnt(swap_btf), btf__type_cnt(btf), "nr_types");
|
||||
|
||||
swap_raw_data = btf__get_raw_data(swap_btf, &swap_raw_sz);
|
||||
swap_raw_data = btf__raw_data(swap_btf, &swap_raw_sz);
|
||||
if (!ASSERT_OK_PTR(swap_raw_data, "swap_raw_data"))
|
||||
goto err_out;
|
||||
|
||||
|
|
@ -58,7 +58,7 @@ void test_btf_endian() {
|
|||
|
||||
/* swap it back to native endianness */
|
||||
btf__set_endianness(swap_btf, endian);
|
||||
swap_raw_data = btf__get_raw_data(swap_btf, &swap_raw_sz);
|
||||
swap_raw_data = btf__raw_data(swap_btf, &swap_raw_sz);
|
||||
if (!ASSERT_OK_PTR(swap_raw_data, "swap_raw_data"))
|
||||
goto err_out;
|
||||
|
||||
|
|
@ -75,7 +75,7 @@ void test_btf_endian() {
|
|||
swap_btf = NULL;
|
||||
|
||||
btf__set_endianness(btf, swap_endian);
|
||||
raw_data = btf__get_raw_data(btf, &raw_sz);
|
||||
raw_data = btf__raw_data(btf, &raw_sz);
|
||||
if (!ASSERT_OK_PTR(raw_data, "raw_data_inverted"))
|
||||
goto err_out;
|
||||
|
||||
|
|
@ -85,7 +85,7 @@ void test_btf_endian() {
|
|||
goto err_out;
|
||||
|
||||
ASSERT_EQ(btf__endianness(swap_btf), swap_endian, "endian");
|
||||
ASSERT_EQ(btf__get_nr_types(swap_btf), btf__get_nr_types(btf), "nr_types");
|
||||
ASSERT_EQ(btf__type_cnt(swap_btf), btf__type_cnt(btf), "nr_types");
|
||||
|
||||
/* the type should appear as if it was stored in native endianness */
|
||||
t = btf__type_by_id(swap_btf, var_id);
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ void test_btf_split() {
|
|||
d = btf_dump__new(btf2, NULL, &opts, btf_dump_printf);
|
||||
if (!ASSERT_OK_PTR(d, "btf_dump__new"))
|
||||
goto cleanup;
|
||||
for (i = 1; i <= btf__get_nr_types(btf2); i++) {
|
||||
for (i = 1; i < btf__type_cnt(btf2); i++) {
|
||||
err = btf_dump__dump_type(d, i);
|
||||
ASSERT_OK(err, "dump_type_ok");
|
||||
}
|
||||
|
|
|
|||
20
tools/testing/selftests/bpf/prog_tests/btf_tag.c
Normal file
20
tools/testing/selftests/bpf/prog_tests/btf_tag.c
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Copyright (c) 2021 Facebook */
|
||||
#include <test_progs.h>
|
||||
#include "tag.skel.h"
|
||||
|
||||
void test_btf_tag(void)
|
||||
{
|
||||
struct tag *skel;
|
||||
|
||||
skel = tag__open_and_load();
|
||||
if (!ASSERT_OK_PTR(skel, "btf_tag"))
|
||||
return;
|
||||
|
||||
if (skel->rodata->skip_tests) {
|
||||
printf("%s:SKIP: btf_tag attribute not supported", __func__);
|
||||
test__skip();
|
||||
}
|
||||
|
||||
tag__destroy(skel);
|
||||
}
|
||||
|
|
@ -4,19 +4,15 @@
|
|||
#include <bpf/btf.h>
|
||||
#include "btf_helpers.h"
|
||||
|
||||
void test_btf_write() {
|
||||
static void gen_btf(struct btf *btf)
|
||||
{
|
||||
const struct btf_var_secinfo *vi;
|
||||
const struct btf_type *t;
|
||||
const struct btf_member *m;
|
||||
const struct btf_enum *v;
|
||||
const struct btf_param *p;
|
||||
struct btf *btf;
|
||||
int id, err, str_off;
|
||||
|
||||
btf = btf__new_empty();
|
||||
if (!ASSERT_OK_PTR(btf, "new_empty"))
|
||||
return;
|
||||
|
||||
str_off = btf__find_str(btf, "int");
|
||||
ASSERT_EQ(str_off, -ENOENT, "int_str_missing_off");
|
||||
|
||||
|
|
@ -281,5 +277,159 @@ void test_btf_write() {
|
|||
"[17] DATASEC 'datasec1' size=12 vlen=1\n"
|
||||
"\ttype_id=1 offset=4 size=8", "raw_dump");
|
||||
|
||||
/* DECL_TAG */
|
||||
id = btf__add_decl_tag(btf, "tag1", 16, -1);
|
||||
ASSERT_EQ(id, 18, "tag_id");
|
||||
t = btf__type_by_id(btf, 18);
|
||||
ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "tag1", "tag_value");
|
||||
ASSERT_EQ(btf_kind(t), BTF_KIND_DECL_TAG, "tag_kind");
|
||||
ASSERT_EQ(t->type, 16, "tag_type");
|
||||
ASSERT_EQ(btf_decl_tag(t)->component_idx, -1, "tag_component_idx");
|
||||
ASSERT_STREQ(btf_type_raw_dump(btf, 18),
|
||||
"[18] DECL_TAG 'tag1' type_id=16 component_idx=-1", "raw_dump");
|
||||
|
||||
id = btf__add_decl_tag(btf, "tag2", 14, 1);
|
||||
ASSERT_EQ(id, 19, "tag_id");
|
||||
t = btf__type_by_id(btf, 19);
|
||||
ASSERT_STREQ(btf__str_by_offset(btf, t->name_off), "tag2", "tag_value");
|
||||
ASSERT_EQ(btf_kind(t), BTF_KIND_DECL_TAG, "tag_kind");
|
||||
ASSERT_EQ(t->type, 14, "tag_type");
|
||||
ASSERT_EQ(btf_decl_tag(t)->component_idx, 1, "tag_component_idx");
|
||||
ASSERT_STREQ(btf_type_raw_dump(btf, 19),
|
||||
"[19] DECL_TAG 'tag2' type_id=14 component_idx=1", "raw_dump");
|
||||
}
|
||||
|
||||
static void test_btf_add()
|
||||
{
|
||||
struct btf *btf;
|
||||
|
||||
btf = btf__new_empty();
|
||||
if (!ASSERT_OK_PTR(btf, "new_empty"))
|
||||
return;
|
||||
|
||||
gen_btf(btf);
|
||||
|
||||
VALIDATE_RAW_BTF(
|
||||
btf,
|
||||
"[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED",
|
||||
"[2] PTR '(anon)' type_id=1",
|
||||
"[3] CONST '(anon)' type_id=5",
|
||||
"[4] VOLATILE '(anon)' type_id=3",
|
||||
"[5] RESTRICT '(anon)' type_id=4",
|
||||
"[6] ARRAY '(anon)' type_id=2 index_type_id=1 nr_elems=10",
|
||||
"[7] STRUCT 's1' size=8 vlen=2\n"
|
||||
"\t'f1' type_id=1 bits_offset=0\n"
|
||||
"\t'f2' type_id=1 bits_offset=32 bitfield_size=16",
|
||||
"[8] UNION 'u1' size=8 vlen=1\n"
|
||||
"\t'f1' type_id=1 bits_offset=0 bitfield_size=16",
|
||||
"[9] ENUM 'e1' size=4 vlen=2\n"
|
||||
"\t'v1' val=1\n"
|
||||
"\t'v2' val=2",
|
||||
"[10] FWD 'struct_fwd' fwd_kind=struct",
|
||||
"[11] FWD 'union_fwd' fwd_kind=union",
|
||||
"[12] ENUM 'enum_fwd' size=4 vlen=0",
|
||||
"[13] TYPEDEF 'typedef1' type_id=1",
|
||||
"[14] FUNC 'func1' type_id=15 linkage=global",
|
||||
"[15] FUNC_PROTO '(anon)' ret_type_id=1 vlen=2\n"
|
||||
"\t'p1' type_id=1\n"
|
||||
"\t'p2' type_id=2",
|
||||
"[16] VAR 'var1' type_id=1, linkage=global-alloc",
|
||||
"[17] DATASEC 'datasec1' size=12 vlen=1\n"
|
||||
"\ttype_id=1 offset=4 size=8",
|
||||
"[18] DECL_TAG 'tag1' type_id=16 component_idx=-1",
|
||||
"[19] DECL_TAG 'tag2' type_id=14 component_idx=1");
|
||||
|
||||
btf__free(btf);
|
||||
}
|
||||
|
||||
static void test_btf_add_btf()
|
||||
{
|
||||
struct btf *btf1 = NULL, *btf2 = NULL;
|
||||
int id;
|
||||
|
||||
btf1 = btf__new_empty();
|
||||
if (!ASSERT_OK_PTR(btf1, "btf1"))
|
||||
return;
|
||||
|
||||
btf2 = btf__new_empty();
|
||||
if (!ASSERT_OK_PTR(btf2, "btf2"))
|
||||
goto cleanup;
|
||||
|
||||
gen_btf(btf1);
|
||||
gen_btf(btf2);
|
||||
|
||||
id = btf__add_btf(btf1, btf2);
|
||||
if (!ASSERT_EQ(id, 20, "id"))
|
||||
goto cleanup;
|
||||
|
||||
VALIDATE_RAW_BTF(
|
||||
btf1,
|
||||
"[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED",
|
||||
"[2] PTR '(anon)' type_id=1",
|
||||
"[3] CONST '(anon)' type_id=5",
|
||||
"[4] VOLATILE '(anon)' type_id=3",
|
||||
"[5] RESTRICT '(anon)' type_id=4",
|
||||
"[6] ARRAY '(anon)' type_id=2 index_type_id=1 nr_elems=10",
|
||||
"[7] STRUCT 's1' size=8 vlen=2\n"
|
||||
"\t'f1' type_id=1 bits_offset=0\n"
|
||||
"\t'f2' type_id=1 bits_offset=32 bitfield_size=16",
|
||||
"[8] UNION 'u1' size=8 vlen=1\n"
|
||||
"\t'f1' type_id=1 bits_offset=0 bitfield_size=16",
|
||||
"[9] ENUM 'e1' size=4 vlen=2\n"
|
||||
"\t'v1' val=1\n"
|
||||
"\t'v2' val=2",
|
||||
"[10] FWD 'struct_fwd' fwd_kind=struct",
|
||||
"[11] FWD 'union_fwd' fwd_kind=union",
|
||||
"[12] ENUM 'enum_fwd' size=4 vlen=0",
|
||||
"[13] TYPEDEF 'typedef1' type_id=1",
|
||||
"[14] FUNC 'func1' type_id=15 linkage=global",
|
||||
"[15] FUNC_PROTO '(anon)' ret_type_id=1 vlen=2\n"
|
||||
"\t'p1' type_id=1\n"
|
||||
"\t'p2' type_id=2",
|
||||
"[16] VAR 'var1' type_id=1, linkage=global-alloc",
|
||||
"[17] DATASEC 'datasec1' size=12 vlen=1\n"
|
||||
"\ttype_id=1 offset=4 size=8",
|
||||
"[18] DECL_TAG 'tag1' type_id=16 component_idx=-1",
|
||||
"[19] DECL_TAG 'tag2' type_id=14 component_idx=1",
|
||||
|
||||
/* types appended from the second BTF */
|
||||
"[20] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED",
|
||||
"[21] PTR '(anon)' type_id=20",
|
||||
"[22] CONST '(anon)' type_id=24",
|
||||
"[23] VOLATILE '(anon)' type_id=22",
|
||||
"[24] RESTRICT '(anon)' type_id=23",
|
||||
"[25] ARRAY '(anon)' type_id=21 index_type_id=20 nr_elems=10",
|
||||
"[26] STRUCT 's1' size=8 vlen=2\n"
|
||||
"\t'f1' type_id=20 bits_offset=0\n"
|
||||
"\t'f2' type_id=20 bits_offset=32 bitfield_size=16",
|
||||
"[27] UNION 'u1' size=8 vlen=1\n"
|
||||
"\t'f1' type_id=20 bits_offset=0 bitfield_size=16",
|
||||
"[28] ENUM 'e1' size=4 vlen=2\n"
|
||||
"\t'v1' val=1\n"
|
||||
"\t'v2' val=2",
|
||||
"[29] FWD 'struct_fwd' fwd_kind=struct",
|
||||
"[30] FWD 'union_fwd' fwd_kind=union",
|
||||
"[31] ENUM 'enum_fwd' size=4 vlen=0",
|
||||
"[32] TYPEDEF 'typedef1' type_id=20",
|
||||
"[33] FUNC 'func1' type_id=34 linkage=global",
|
||||
"[34] FUNC_PROTO '(anon)' ret_type_id=20 vlen=2\n"
|
||||
"\t'p1' type_id=20\n"
|
||||
"\t'p2' type_id=21",
|
||||
"[35] VAR 'var1' type_id=20, linkage=global-alloc",
|
||||
"[36] DATASEC 'datasec1' size=12 vlen=1\n"
|
||||
"\ttype_id=20 offset=4 size=8",
|
||||
"[37] DECL_TAG 'tag1' type_id=35 component_idx=-1",
|
||||
"[38] DECL_TAG 'tag2' type_id=33 component_idx=1");
|
||||
|
||||
cleanup:
|
||||
btf__free(btf1);
|
||||
btf__free(btf2);
|
||||
}
|
||||
|
||||
void test_btf_write()
|
||||
{
|
||||
if (test__start_subtest("btf_add"))
|
||||
test_btf_add();
|
||||
if (test__start_subtest("btf_add_btf"))
|
||||
test_btf_add_btf();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -363,7 +363,7 @@ close_bpf_object:
|
|||
cg_storage_multi_shared__destroy(obj);
|
||||
}
|
||||
|
||||
void test_cg_storage_multi(void)
|
||||
void serial_test_cg_storage_multi(void)
|
||||
{
|
||||
int parent_cgroup_fd = -1, child_cgroup_fd = -1;
|
||||
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ static int prog_load(void)
|
|||
bpf_log_buf, BPF_LOG_BUF_SIZE);
|
||||
}
|
||||
|
||||
void test_cgroup_attach_autodetach(void)
|
||||
void serial_test_cgroup_attach_autodetach(void)
|
||||
{
|
||||
__u32 duration = 0, prog_cnt = 4, attach_flags;
|
||||
int allow_prog[2] = {-1};
|
||||
|
|
|
|||
|
|
@ -74,7 +74,7 @@ static int prog_load_cnt(int verdict, int val)
|
|||
return ret;
|
||||
}
|
||||
|
||||
void test_cgroup_attach_multi(void)
|
||||
void serial_test_cgroup_attach_multi(void)
|
||||
{
|
||||
__u32 prog_ids[4], prog_cnt = 0, attach_flags, saved_prog_id;
|
||||
int cg1 = 0, cg2 = 0, cg3 = 0, cg4 = 0, cg5 = 0, key = 0;
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ static int prog_load(int verdict)
|
|||
bpf_log_buf, BPF_LOG_BUF_SIZE);
|
||||
}
|
||||
|
||||
void test_cgroup_attach_override(void)
|
||||
void serial_test_cgroup_attach_override(void)
|
||||
{
|
||||
int drop_prog = -1, allow_prog = -1, foo = -1, bar = -1;
|
||||
__u32 duration = 0;
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ int ping_and_check(int exp_calls, int exp_alt_calls)
|
|||
return 0;
|
||||
}
|
||||
|
||||
void test_cgroup_link(void)
|
||||
void serial_test_cgroup_link(void)
|
||||
{
|
||||
struct {
|
||||
const char *path;
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ void test_cgroup_v1v2(void)
|
|||
{
|
||||
struct network_helper_opts opts = {};
|
||||
int server_fd, client_fd, cgroup_fd;
|
||||
static const int port = 60123;
|
||||
static const int port = 60120;
|
||||
|
||||
/* Step 1: Check base connectivity works without any BPF. */
|
||||
server_fd = start_server(AF_INET, SOCK_STREAM, NULL, port, 0);
|
||||
|
|
|
|||
|
|
@ -195,7 +195,7 @@ cleanup:
|
|||
test_check_mtu__destroy(skel);
|
||||
}
|
||||
|
||||
void test_check_mtu(void)
|
||||
void serial_test_check_mtu(void)
|
||||
{
|
||||
__u32 mtu_lo;
|
||||
|
||||
|
|
|
|||
|
|
@ -112,7 +112,7 @@ void test_core_autosize(void)
|
|||
if (!ASSERT_OK_PTR(f, "btf_fdopen"))
|
||||
goto cleanup;
|
||||
|
||||
raw_data = btf__get_raw_data(btf, &raw_sz);
|
||||
raw_data = btf__raw_data(btf, &raw_sz);
|
||||
if (!ASSERT_OK_PTR(raw_data, "raw_data"))
|
||||
goto cleanup;
|
||||
written = fwrite(raw_data, 1, raw_sz, f);
|
||||
|
|
@ -163,7 +163,7 @@ void test_core_autosize(void)
|
|||
|
||||
usleep(1);
|
||||
|
||||
bss_map = bpf_object__find_map_by_name(skel->obj, "test_cor.bss");
|
||||
bss_map = bpf_object__find_map_by_name(skel->obj, ".bss");
|
||||
if (!ASSERT_OK_PTR(bss_map, "bss_map_find"))
|
||||
goto cleanup;
|
||||
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ static int duration = 0;
|
|||
.output_len = sizeof(struct core_reloc_module_output), \
|
||||
.prog_sec_name = sec_name, \
|
||||
.raw_tp_name = tp_name, \
|
||||
.trigger = trigger_module_test_read, \
|
||||
.trigger = __trigger_module_test_read, \
|
||||
.needs_testmod = true, \
|
||||
}
|
||||
|
||||
|
|
@ -249,8 +249,7 @@ static int duration = 0;
|
|||
#define SIZE_CASE_COMMON(name) \
|
||||
.case_name = #name, \
|
||||
.bpf_obj_file = "test_core_reloc_size.o", \
|
||||
.btf_src_file = "btf__core_reloc_" #name ".o", \
|
||||
.relaxed_core_relocs = true
|
||||
.btf_src_file = "btf__core_reloc_" #name ".o"
|
||||
|
||||
#define SIZE_OUTPUT_DATA(type) \
|
||||
STRUCT_TO_CHAR_PTR(core_reloc_size_output) { \
|
||||
|
|
@ -382,7 +381,7 @@ static int setup_type_id_case_local(struct core_reloc_test_case *test)
|
|||
exp->local_anon_void_ptr = -1;
|
||||
exp->local_anon_arr = -1;
|
||||
|
||||
for (i = 1; i <= btf__get_nr_types(local_btf); i++)
|
||||
for (i = 1; i < btf__type_cnt(local_btf); i++)
|
||||
{
|
||||
t = btf__type_by_id(local_btf, i);
|
||||
/* we are interested only in anonymous types */
|
||||
|
|
@ -475,19 +474,11 @@ static int setup_type_id_case_failure(struct core_reloc_test_case *test)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int trigger_module_test_read(const struct core_reloc_test_case *test)
|
||||
static int __trigger_module_test_read(const struct core_reloc_test_case *test)
|
||||
{
|
||||
struct core_reloc_module_output *exp = (void *)test->output;
|
||||
int fd, err;
|
||||
|
||||
fd = open("/sys/kernel/bpf_testmod", O_RDONLY);
|
||||
err = -errno;
|
||||
if (CHECK(fd < 0, "testmod_file_open", "failed: %d\n", err))
|
||||
return err;
|
||||
|
||||
read(fd, NULL, exp->len); /* request expected number of bytes */
|
||||
close(fd);
|
||||
|
||||
trigger_module_test_read(exp->len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -876,7 +867,7 @@ void test_core_reloc(void)
|
|||
goto cleanup;
|
||||
}
|
||||
|
||||
data_map = bpf_object__find_map_by_name(obj, "test_cor.bss");
|
||||
data_map = bpf_object__find_map_by_name(obj, ".bss");
|
||||
if (CHECK(!data_map, "find_data_map", "data map not found\n"))
|
||||
goto cleanup;
|
||||
|
||||
|
|
|
|||
115
tools/testing/selftests/bpf/prog_tests/dummy_st_ops.c
Normal file
115
tools/testing/selftests/bpf/prog_tests/dummy_st_ops.c
Normal file
|
|
@ -0,0 +1,115 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Copyright (C) 2021. Huawei Technologies Co., Ltd */
|
||||
#include <test_progs.h>
|
||||
#include "dummy_st_ops.skel.h"
|
||||
|
||||
/* Need to keep consistent with definition in include/linux/bpf.h */
|
||||
struct bpf_dummy_ops_state {
|
||||
int val;
|
||||
};
|
||||
|
||||
static void test_dummy_st_ops_attach(void)
|
||||
{
|
||||
struct dummy_st_ops *skel;
|
||||
struct bpf_link *link;
|
||||
|
||||
skel = dummy_st_ops__open_and_load();
|
||||
if (!ASSERT_OK_PTR(skel, "dummy_st_ops_load"))
|
||||
return;
|
||||
|
||||
link = bpf_map__attach_struct_ops(skel->maps.dummy_1);
|
||||
ASSERT_EQ(libbpf_get_error(link), -EOPNOTSUPP, "dummy_st_ops_attach");
|
||||
|
||||
dummy_st_ops__destroy(skel);
|
||||
}
|
||||
|
||||
static void test_dummy_init_ret_value(void)
|
||||
{
|
||||
__u64 args[1] = {0};
|
||||
struct bpf_prog_test_run_attr attr = {
|
||||
.ctx_size_in = sizeof(args),
|
||||
.ctx_in = args,
|
||||
};
|
||||
struct dummy_st_ops *skel;
|
||||
int fd, err;
|
||||
|
||||
skel = dummy_st_ops__open_and_load();
|
||||
if (!ASSERT_OK_PTR(skel, "dummy_st_ops_load"))
|
||||
return;
|
||||
|
||||
fd = bpf_program__fd(skel->progs.test_1);
|
||||
attr.prog_fd = fd;
|
||||
err = bpf_prog_test_run_xattr(&attr);
|
||||
ASSERT_OK(err, "test_run");
|
||||
ASSERT_EQ(attr.retval, 0xf2f3f4f5, "test_ret");
|
||||
|
||||
dummy_st_ops__destroy(skel);
|
||||
}
|
||||
|
||||
static void test_dummy_init_ptr_arg(void)
|
||||
{
|
||||
int exp_retval = 0xbeef;
|
||||
struct bpf_dummy_ops_state in_state = {
|
||||
.val = exp_retval,
|
||||
};
|
||||
__u64 args[1] = {(unsigned long)&in_state};
|
||||
struct bpf_prog_test_run_attr attr = {
|
||||
.ctx_size_in = sizeof(args),
|
||||
.ctx_in = args,
|
||||
};
|
||||
struct dummy_st_ops *skel;
|
||||
int fd, err;
|
||||
|
||||
skel = dummy_st_ops__open_and_load();
|
||||
if (!ASSERT_OK_PTR(skel, "dummy_st_ops_load"))
|
||||
return;
|
||||
|
||||
fd = bpf_program__fd(skel->progs.test_1);
|
||||
attr.prog_fd = fd;
|
||||
err = bpf_prog_test_run_xattr(&attr);
|
||||
ASSERT_OK(err, "test_run");
|
||||
ASSERT_EQ(in_state.val, 0x5a, "test_ptr_ret");
|
||||
ASSERT_EQ(attr.retval, exp_retval, "test_ret");
|
||||
|
||||
dummy_st_ops__destroy(skel);
|
||||
}
|
||||
|
||||
static void test_dummy_multiple_args(void)
|
||||
{
|
||||
__u64 args[5] = {0, -100, 0x8a5f, 'c', 0x1234567887654321ULL};
|
||||
struct bpf_prog_test_run_attr attr = {
|
||||
.ctx_size_in = sizeof(args),
|
||||
.ctx_in = args,
|
||||
};
|
||||
struct dummy_st_ops *skel;
|
||||
int fd, err;
|
||||
size_t i;
|
||||
char name[8];
|
||||
|
||||
skel = dummy_st_ops__open_and_load();
|
||||
if (!ASSERT_OK_PTR(skel, "dummy_st_ops_load"))
|
||||
return;
|
||||
|
||||
fd = bpf_program__fd(skel->progs.test_2);
|
||||
attr.prog_fd = fd;
|
||||
err = bpf_prog_test_run_xattr(&attr);
|
||||
ASSERT_OK(err, "test_run");
|
||||
for (i = 0; i < ARRAY_SIZE(args); i++) {
|
||||
snprintf(name, sizeof(name), "arg %zu", i);
|
||||
ASSERT_EQ(skel->bss->test_2_args[i], args[i], name);
|
||||
}
|
||||
|
||||
dummy_st_ops__destroy(skel);
|
||||
}
|
||||
|
||||
void test_dummy_st_ops(void)
|
||||
{
|
||||
if (test__start_subtest("dummy_st_ops_attach"))
|
||||
test_dummy_st_ops_attach();
|
||||
if (test__start_subtest("dummy_init_ret_value"))
|
||||
test_dummy_init_ret_value();
|
||||
if (test__start_subtest("dummy_init_ptr_arg"))
|
||||
test_dummy_init_ptr_arg();
|
||||
if (test__start_subtest("dummy_multiple_args"))
|
||||
test_dummy_multiple_args();
|
||||
}
|
||||
|
|
@ -6,23 +6,23 @@
|
|||
|
||||
void test_fentry_fexit(void)
|
||||
{
|
||||
struct fentry_test *fentry_skel = NULL;
|
||||
struct fexit_test *fexit_skel = NULL;
|
||||
struct fentry_test_lskel *fentry_skel = NULL;
|
||||
struct fexit_test_lskel *fexit_skel = NULL;
|
||||
__u64 *fentry_res, *fexit_res;
|
||||
__u32 duration = 0, retval;
|
||||
int err, prog_fd, i;
|
||||
|
||||
fentry_skel = fentry_test__open_and_load();
|
||||
fentry_skel = fentry_test_lskel__open_and_load();
|
||||
if (CHECK(!fentry_skel, "fentry_skel_load", "fentry skeleton failed\n"))
|
||||
goto close_prog;
|
||||
fexit_skel = fexit_test__open_and_load();
|
||||
fexit_skel = fexit_test_lskel__open_and_load();
|
||||
if (CHECK(!fexit_skel, "fexit_skel_load", "fexit skeleton failed\n"))
|
||||
goto close_prog;
|
||||
|
||||
err = fentry_test__attach(fentry_skel);
|
||||
err = fentry_test_lskel__attach(fentry_skel);
|
||||
if (CHECK(err, "fentry_attach", "fentry attach failed: %d\n", err))
|
||||
goto close_prog;
|
||||
err = fexit_test__attach(fexit_skel);
|
||||
err = fexit_test_lskel__attach(fexit_skel);
|
||||
if (CHECK(err, "fexit_attach", "fexit attach failed: %d\n", err))
|
||||
goto close_prog;
|
||||
|
||||
|
|
@ -44,6 +44,6 @@ void test_fentry_fexit(void)
|
|||
}
|
||||
|
||||
close_prog:
|
||||
fentry_test__destroy(fentry_skel);
|
||||
fexit_test__destroy(fexit_skel);
|
||||
fentry_test_lskel__destroy(fentry_skel);
|
||||
fexit_test_lskel__destroy(fexit_skel);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,19 +3,19 @@
|
|||
#include <test_progs.h>
|
||||
#include "fentry_test.lskel.h"
|
||||
|
||||
static int fentry_test(struct fentry_test *fentry_skel)
|
||||
static int fentry_test(struct fentry_test_lskel *fentry_skel)
|
||||
{
|
||||
int err, prog_fd, i;
|
||||
__u32 duration = 0, retval;
|
||||
int link_fd;
|
||||
__u64 *result;
|
||||
|
||||
err = fentry_test__attach(fentry_skel);
|
||||
err = fentry_test_lskel__attach(fentry_skel);
|
||||
if (!ASSERT_OK(err, "fentry_attach"))
|
||||
return err;
|
||||
|
||||
/* Check that already linked program can't be attached again. */
|
||||
link_fd = fentry_test__test1__attach(fentry_skel);
|
||||
link_fd = fentry_test_lskel__test1__attach(fentry_skel);
|
||||
if (!ASSERT_LT(link_fd, 0, "fentry_attach_link"))
|
||||
return -1;
|
||||
|
||||
|
|
@ -31,7 +31,7 @@ static int fentry_test(struct fentry_test *fentry_skel)
|
|||
return -1;
|
||||
}
|
||||
|
||||
fentry_test__detach(fentry_skel);
|
||||
fentry_test_lskel__detach(fentry_skel);
|
||||
|
||||
/* zero results for re-attach test */
|
||||
memset(fentry_skel->bss, 0, sizeof(*fentry_skel->bss));
|
||||
|
|
@ -40,10 +40,10 @@ static int fentry_test(struct fentry_test *fentry_skel)
|
|||
|
||||
void test_fentry_test(void)
|
||||
{
|
||||
struct fentry_test *fentry_skel = NULL;
|
||||
struct fentry_test_lskel *fentry_skel = NULL;
|
||||
int err;
|
||||
|
||||
fentry_skel = fentry_test__open_and_load();
|
||||
fentry_skel = fentry_test_lskel__open_and_load();
|
||||
if (!ASSERT_OK_PTR(fentry_skel, "fentry_skel_load"))
|
||||
goto cleanup;
|
||||
|
||||
|
|
@ -55,5 +55,5 @@ void test_fentry_test(void)
|
|||
ASSERT_OK(err, "fentry_second_attach");
|
||||
|
||||
cleanup:
|
||||
fentry_test__destroy(fentry_skel);
|
||||
fentry_test_lskel__destroy(fentry_skel);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -60,7 +60,7 @@ static void test_fexit_bpf2bpf_common(const char *obj_file,
|
|||
struct bpf_object *obj = NULL, *tgt_obj;
|
||||
__u32 retval, tgt_prog_id, info_len;
|
||||
struct bpf_prog_info prog_info = {};
|
||||
struct bpf_program **prog = NULL;
|
||||
struct bpf_program **prog = NULL, *p;
|
||||
struct bpf_link **link = NULL;
|
||||
int err, tgt_fd, i;
|
||||
struct btf *btf;
|
||||
|
|
@ -69,9 +69,6 @@ static void test_fexit_bpf2bpf_common(const char *obj_file,
|
|||
&tgt_obj, &tgt_fd);
|
||||
if (!ASSERT_OK(err, "tgt_prog_load"))
|
||||
return;
|
||||
DECLARE_LIBBPF_OPTS(bpf_object_open_opts, opts,
|
||||
.attach_prog_fd = tgt_fd,
|
||||
);
|
||||
|
||||
info_len = sizeof(prog_info);
|
||||
err = bpf_obj_get_info_by_fd(tgt_fd, &prog_info, &info_len);
|
||||
|
|
@ -89,10 +86,15 @@ static void test_fexit_bpf2bpf_common(const char *obj_file,
|
|||
if (!ASSERT_OK_PTR(prog, "prog_ptr"))
|
||||
goto close_prog;
|
||||
|
||||
obj = bpf_object__open_file(obj_file, &opts);
|
||||
obj = bpf_object__open_file(obj_file, NULL);
|
||||
if (!ASSERT_OK_PTR(obj, "obj_open"))
|
||||
goto close_prog;
|
||||
|
||||
bpf_object__for_each_program(p, obj) {
|
||||
err = bpf_program__set_attach_target(p, tgt_fd, NULL);
|
||||
ASSERT_OK(err, "set_attach_target");
|
||||
}
|
||||
|
||||
err = bpf_object__load(obj);
|
||||
if (!ASSERT_OK(err, "obj_load"))
|
||||
goto close_prog;
|
||||
|
|
@ -270,7 +272,7 @@ static void test_fmod_ret_freplace(void)
|
|||
struct bpf_link *freplace_link = NULL;
|
||||
struct bpf_program *prog;
|
||||
__u32 duration = 0;
|
||||
int err, pkt_fd;
|
||||
int err, pkt_fd, attach_prog_fd;
|
||||
|
||||
err = bpf_prog_load(tgt_name, BPF_PROG_TYPE_UNSPEC,
|
||||
&pkt_obj, &pkt_fd);
|
||||
|
|
@ -278,26 +280,32 @@ static void test_fmod_ret_freplace(void)
|
|||
if (CHECK(err, "tgt_prog_load", "file %s err %d errno %d\n",
|
||||
tgt_name, err, errno))
|
||||
return;
|
||||
opts.attach_prog_fd = pkt_fd;
|
||||
|
||||
freplace_obj = bpf_object__open_file(freplace_name, &opts);
|
||||
freplace_obj = bpf_object__open_file(freplace_name, NULL);
|
||||
if (!ASSERT_OK_PTR(freplace_obj, "freplace_obj_open"))
|
||||
goto out;
|
||||
|
||||
prog = bpf_object__next_program(freplace_obj, NULL);
|
||||
err = bpf_program__set_attach_target(prog, pkt_fd, NULL);
|
||||
ASSERT_OK(err, "freplace__set_attach_target");
|
||||
|
||||
err = bpf_object__load(freplace_obj);
|
||||
if (CHECK(err, "freplace_obj_load", "err %d\n", err))
|
||||
goto out;
|
||||
|
||||
prog = bpf_program__next(NULL, freplace_obj);
|
||||
freplace_link = bpf_program__attach_trace(prog);
|
||||
if (!ASSERT_OK_PTR(freplace_link, "freplace_attach_trace"))
|
||||
goto out;
|
||||
|
||||
opts.attach_prog_fd = bpf_program__fd(prog);
|
||||
fmod_obj = bpf_object__open_file(fmod_ret_name, &opts);
|
||||
fmod_obj = bpf_object__open_file(fmod_ret_name, NULL);
|
||||
if (!ASSERT_OK_PTR(fmod_obj, "fmod_obj_open"))
|
||||
goto out;
|
||||
|
||||
attach_prog_fd = bpf_program__fd(prog);
|
||||
prog = bpf_object__next_program(fmod_obj, NULL);
|
||||
err = bpf_program__set_attach_target(prog, attach_prog_fd, NULL);
|
||||
ASSERT_OK(err, "fmod_ret_set_attach_target");
|
||||
|
||||
err = bpf_object__load(fmod_obj);
|
||||
if (CHECK(!err, "fmod_obj_load", "loading fmod_ret should fail\n"))
|
||||
goto out;
|
||||
|
|
@ -322,14 +330,14 @@ static void test_func_sockmap_update(void)
|
|||
}
|
||||
|
||||
static void test_obj_load_failure_common(const char *obj_file,
|
||||
const char *target_obj_file)
|
||||
|
||||
const char *target_obj_file)
|
||||
{
|
||||
/*
|
||||
* standalone test that asserts failure to load freplace prog
|
||||
* because of invalid return code.
|
||||
*/
|
||||
struct bpf_object *obj = NULL, *pkt_obj;
|
||||
struct bpf_program *prog;
|
||||
int err, pkt_fd;
|
||||
__u32 duration = 0;
|
||||
|
||||
|
|
@ -339,14 +347,15 @@ static void test_obj_load_failure_common(const char *obj_file,
|
|||
if (CHECK(err, "tgt_prog_load", "file %s err %d errno %d\n",
|
||||
target_obj_file, err, errno))
|
||||
return;
|
||||
DECLARE_LIBBPF_OPTS(bpf_object_open_opts, opts,
|
||||
.attach_prog_fd = pkt_fd,
|
||||
);
|
||||
|
||||
obj = bpf_object__open_file(obj_file, &opts);
|
||||
obj = bpf_object__open_file(obj_file, NULL);
|
||||
if (!ASSERT_OK_PTR(obj, "obj_open"))
|
||||
goto close_prog;
|
||||
|
||||
prog = bpf_object__next_program(obj, NULL);
|
||||
err = bpf_program__set_attach_target(prog, pkt_fd, NULL);
|
||||
ASSERT_OK(err, "set_attach_target");
|
||||
|
||||
/* It should fail to load the program */
|
||||
err = bpf_object__load(obj);
|
||||
if (CHECK(!err, "bpf_obj_load should fail", "err %d\n", err))
|
||||
|
|
@ -371,7 +380,8 @@ static void test_func_map_prog_compatibility(void)
|
|||
"./test_attach_probe.o");
|
||||
}
|
||||
|
||||
void test_fexit_bpf2bpf(void)
|
||||
/* NOTE: affect other tests, must run in serial mode */
|
||||
void serial_test_fexit_bpf2bpf(void)
|
||||
{
|
||||
if (test__start_subtest("target_no_callees"))
|
||||
test_target_no_callees();
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
|
||||
static int do_sleep(void *skel)
|
||||
{
|
||||
struct fexit_sleep *fexit_skel = skel;
|
||||
struct fexit_sleep_lskel *fexit_skel = skel;
|
||||
struct timespec ts1 = { .tv_nsec = 1 };
|
||||
struct timespec ts2 = { .tv_sec = 10 };
|
||||
|
||||
|
|
@ -25,16 +25,16 @@ static char child_stack[STACK_SIZE];
|
|||
|
||||
void test_fexit_sleep(void)
|
||||
{
|
||||
struct fexit_sleep *fexit_skel = NULL;
|
||||
struct fexit_sleep_lskel *fexit_skel = NULL;
|
||||
int wstatus, duration = 0;
|
||||
pid_t cpid;
|
||||
int err, fexit_cnt;
|
||||
|
||||
fexit_skel = fexit_sleep__open_and_load();
|
||||
fexit_skel = fexit_sleep_lskel__open_and_load();
|
||||
if (CHECK(!fexit_skel, "fexit_skel_load", "fexit skeleton failed\n"))
|
||||
goto cleanup;
|
||||
|
||||
err = fexit_sleep__attach(fexit_skel);
|
||||
err = fexit_sleep_lskel__attach(fexit_skel);
|
||||
if (CHECK(err, "fexit_attach", "fexit attach failed: %d\n", err))
|
||||
goto cleanup;
|
||||
|
||||
|
|
@ -60,7 +60,7 @@ void test_fexit_sleep(void)
|
|||
*/
|
||||
close(fexit_skel->progs.nanosleep_fentry.prog_fd);
|
||||
close(fexit_skel->progs.nanosleep_fexit.prog_fd);
|
||||
fexit_sleep__detach(fexit_skel);
|
||||
fexit_sleep_lskel__detach(fexit_skel);
|
||||
|
||||
/* kill the thread to unwind sys_nanosleep stack through the trampoline */
|
||||
kill(cpid, 9);
|
||||
|
|
@ -78,5 +78,5 @@ void test_fexit_sleep(void)
|
|||
goto cleanup;
|
||||
|
||||
cleanup:
|
||||
fexit_sleep__destroy(fexit_skel);
|
||||
fexit_sleep_lskel__destroy(fexit_skel);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,19 +3,19 @@
|
|||
#include <test_progs.h>
|
||||
#include "fexit_test.lskel.h"
|
||||
|
||||
static int fexit_test(struct fexit_test *fexit_skel)
|
||||
static int fexit_test(struct fexit_test_lskel *fexit_skel)
|
||||
{
|
||||
int err, prog_fd, i;
|
||||
__u32 duration = 0, retval;
|
||||
int link_fd;
|
||||
__u64 *result;
|
||||
|
||||
err = fexit_test__attach(fexit_skel);
|
||||
err = fexit_test_lskel__attach(fexit_skel);
|
||||
if (!ASSERT_OK(err, "fexit_attach"))
|
||||
return err;
|
||||
|
||||
/* Check that already linked program can't be attached again. */
|
||||
link_fd = fexit_test__test1__attach(fexit_skel);
|
||||
link_fd = fexit_test_lskel__test1__attach(fexit_skel);
|
||||
if (!ASSERT_LT(link_fd, 0, "fexit_attach_link"))
|
||||
return -1;
|
||||
|
||||
|
|
@ -31,7 +31,7 @@ static int fexit_test(struct fexit_test *fexit_skel)
|
|||
return -1;
|
||||
}
|
||||
|
||||
fexit_test__detach(fexit_skel);
|
||||
fexit_test_lskel__detach(fexit_skel);
|
||||
|
||||
/* zero results for re-attach test */
|
||||
memset(fexit_skel->bss, 0, sizeof(*fexit_skel->bss));
|
||||
|
|
@ -40,10 +40,10 @@ static int fexit_test(struct fexit_test *fexit_skel)
|
|||
|
||||
void test_fexit_test(void)
|
||||
{
|
||||
struct fexit_test *fexit_skel = NULL;
|
||||
struct fexit_test_lskel *fexit_skel = NULL;
|
||||
int err;
|
||||
|
||||
fexit_skel = fexit_test__open_and_load();
|
||||
fexit_skel = fexit_test_lskel__open_and_load();
|
||||
if (!ASSERT_OK_PTR(fexit_skel, "fexit_skel_load"))
|
||||
goto cleanup;
|
||||
|
||||
|
|
@ -55,5 +55,5 @@ void test_fexit_test(void)
|
|||
ASSERT_OK(err, "fexit_second_attach");
|
||||
|
||||
cleanup:
|
||||
fexit_test__destroy(fexit_skel);
|
||||
fexit_test_lskel__destroy(fexit_skel);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -458,9 +458,9 @@ static int init_prog_array(struct bpf_object *obj, struct bpf_map *prog_array)
|
|||
return -1;
|
||||
|
||||
for (i = 0; i < bpf_map__def(prog_array)->max_entries; i++) {
|
||||
snprintf(prog_name, sizeof(prog_name), "flow_dissector/%i", i);
|
||||
snprintf(prog_name, sizeof(prog_name), "flow_dissector_%d", i);
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, prog_name);
|
||||
prog = bpf_object__find_program_by_name(obj, prog_name);
|
||||
if (!prog)
|
||||
return -1;
|
||||
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
#include <test_progs.h>
|
||||
#include <network_helpers.h>
|
||||
|
||||
void test_flow_dissector_load_bytes(void)
|
||||
void serial_test_flow_dissector_load_bytes(void)
|
||||
{
|
||||
struct bpf_flow_keys flow_keys;
|
||||
__u32 duration = 0, retval, size;
|
||||
|
|
|
|||
|
|
@ -628,7 +628,7 @@ out_close:
|
|||
}
|
||||
}
|
||||
|
||||
void test_flow_dissector_reattach(void)
|
||||
void serial_test_flow_dissector_reattach(void)
|
||||
{
|
||||
int err, new_net, saved_net;
|
||||
|
||||
|
|
|
|||
130
tools/testing/selftests/bpf/prog_tests/get_branch_snapshot.c
Normal file
130
tools/testing/selftests/bpf/prog_tests/get_branch_snapshot.c
Normal file
|
|
@ -0,0 +1,130 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Copyright (c) 2021 Facebook */
|
||||
#include <test_progs.h>
|
||||
#include "get_branch_snapshot.skel.h"
|
||||
|
||||
static int *pfd_array;
|
||||
static int cpu_cnt;
|
||||
|
||||
static bool is_hypervisor(void)
|
||||
{
|
||||
char *line = NULL;
|
||||
bool ret = false;
|
||||
size_t len;
|
||||
FILE *fp;
|
||||
|
||||
fp = fopen("/proc/cpuinfo", "r");
|
||||
if (!fp)
|
||||
return false;
|
||||
|
||||
while (getline(&line, &len, fp) != -1) {
|
||||
if (!strncmp(line, "flags", 5)) {
|
||||
if (strstr(line, "hypervisor") != NULL)
|
||||
ret = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
free(line);
|
||||
fclose(fp);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int create_perf_events(void)
|
||||
{
|
||||
struct perf_event_attr attr = {0};
|
||||
int cpu;
|
||||
|
||||
/* create perf event */
|
||||
attr.size = sizeof(attr);
|
||||
attr.type = PERF_TYPE_RAW;
|
||||
attr.config = 0x1b00;
|
||||
attr.sample_type = PERF_SAMPLE_BRANCH_STACK;
|
||||
attr.branch_sample_type = PERF_SAMPLE_BRANCH_KERNEL |
|
||||
PERF_SAMPLE_BRANCH_USER | PERF_SAMPLE_BRANCH_ANY;
|
||||
|
||||
cpu_cnt = libbpf_num_possible_cpus();
|
||||
pfd_array = malloc(sizeof(int) * cpu_cnt);
|
||||
if (!pfd_array) {
|
||||
cpu_cnt = 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
for (cpu = 0; cpu < cpu_cnt; cpu++) {
|
||||
pfd_array[cpu] = syscall(__NR_perf_event_open, &attr,
|
||||
-1, cpu, -1, PERF_FLAG_FD_CLOEXEC);
|
||||
if (pfd_array[cpu] < 0)
|
||||
break;
|
||||
}
|
||||
|
||||
return cpu == 0;
|
||||
}
|
||||
|
||||
static void close_perf_events(void)
|
||||
{
|
||||
int cpu, fd;
|
||||
|
||||
for (cpu = 0; cpu < cpu_cnt; cpu++) {
|
||||
fd = pfd_array[cpu];
|
||||
if (fd < 0)
|
||||
break;
|
||||
close(fd);
|
||||
}
|
||||
free(pfd_array);
|
||||
}
|
||||
|
||||
void serial_test_get_branch_snapshot(void)
|
||||
{
|
||||
struct get_branch_snapshot *skel = NULL;
|
||||
int err;
|
||||
|
||||
/* Skip the test before we fix LBR snapshot for hypervisor. */
|
||||
if (is_hypervisor()) {
|
||||
test__skip();
|
||||
return;
|
||||
}
|
||||
|
||||
if (create_perf_events()) {
|
||||
test__skip(); /* system doesn't support LBR */
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
skel = get_branch_snapshot__open_and_load();
|
||||
if (!ASSERT_OK_PTR(skel, "get_branch_snapshot__open_and_load"))
|
||||
goto cleanup;
|
||||
|
||||
err = kallsyms_find("bpf_testmod_loop_test", &skel->bss->address_low);
|
||||
if (!ASSERT_OK(err, "kallsyms_find"))
|
||||
goto cleanup;
|
||||
|
||||
/* Just a guess for the end of this function, as module functions
|
||||
* in /proc/kallsyms could come in any order.
|
||||
*/
|
||||
skel->bss->address_high = skel->bss->address_low + 128;
|
||||
|
||||
err = get_branch_snapshot__attach(skel);
|
||||
if (!ASSERT_OK(err, "get_branch_snapshot__attach"))
|
||||
goto cleanup;
|
||||
|
||||
trigger_module_test_read(100);
|
||||
|
||||
if (skel->bss->total_entries < 16) {
|
||||
/* too few entries for the hit/waste test */
|
||||
test__skip();
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
ASSERT_GT(skel->bss->test1_hits, 6, "find_looptest_in_lbr");
|
||||
|
||||
/* Given we stop LBR in software, we will waste a few entries.
|
||||
* But we should try to waste as few as possible entries. We are at
|
||||
* about 7 on x86_64 systems.
|
||||
* Add a check for < 10 so that we get heads-up when something
|
||||
* changes and wastes too many entries.
|
||||
*/
|
||||
ASSERT_LT(skel->bss->wasted_entries, 10, "check_wasted_entries");
|
||||
|
||||
cleanup:
|
||||
get_branch_snapshot__destroy(skel);
|
||||
close_perf_events();
|
||||
}
|
||||
|
|
@ -103,11 +103,18 @@ static void test_global_data_struct(struct bpf_object *obj, __u32 duration)
|
|||
static void test_global_data_rdonly(struct bpf_object *obj, __u32 duration)
|
||||
{
|
||||
int err = -ENOMEM, map_fd, zero = 0;
|
||||
struct bpf_map *map;
|
||||
struct bpf_map *map, *map2;
|
||||
__u8 *buff;
|
||||
|
||||
map = bpf_object__find_map_by_name(obj, "test_glo.rodata");
|
||||
if (CHECK_FAIL(!map || !bpf_map__is_internal(map)))
|
||||
if (!ASSERT_OK_PTR(map, "map"))
|
||||
return;
|
||||
if (!ASSERT_TRUE(bpf_map__is_internal(map), "is_internal"))
|
||||
return;
|
||||
|
||||
/* ensure we can lookup internal maps by their ELF names */
|
||||
map2 = bpf_object__find_map_by_name(obj, ".rodata");
|
||||
if (!ASSERT_EQ(map, map2, "same_maps"))
|
||||
return;
|
||||
|
||||
map_fd = bpf_map__fd(map);
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ void test_global_data_init(void)
|
|||
if (CHECK_FAIL(err))
|
||||
return;
|
||||
|
||||
map = bpf_object__find_map_by_name(obj, "test_glo.rodata");
|
||||
map = bpf_object__find_map_by_name(obj, ".rodata");
|
||||
if (CHECK_FAIL(!map || !bpf_map__is_internal(map)))
|
||||
goto out;
|
||||
|
||||
|
|
|
|||
|
|
@ -48,7 +48,8 @@ static void on_sample(void *ctx, int cpu, void *data, __u32 size)
|
|||
*(bool *)ctx = true;
|
||||
}
|
||||
|
||||
void test_kfree_skb(void)
|
||||
/* TODO: fix kernel panic caused by this test in parallel mode */
|
||||
void serial_test_kfree_skb(void)
|
||||
{
|
||||
struct __sk_buff skb = {};
|
||||
struct bpf_prog_test_run_attr tattr = {
|
||||
|
|
@ -92,7 +93,7 @@ void test_kfree_skb(void)
|
|||
if (CHECK(!fexit, "find_prog", "prog eth_type_trans not found\n"))
|
||||
goto close_prog;
|
||||
|
||||
global_data = bpf_object__find_map_by_name(obj2, "kfree_sk.bss");
|
||||
global_data = bpf_object__find_map_by_name(obj2, ".bss");
|
||||
if (CHECK(!global_data, "find global data", "not found\n"))
|
||||
goto close_prog;
|
||||
|
||||
|
|
|
|||
|
|
@ -7,10 +7,10 @@
|
|||
|
||||
static void test_main(void)
|
||||
{
|
||||
struct kfunc_call_test *skel;
|
||||
struct kfunc_call_test_lskel *skel;
|
||||
int prog_fd, retval, err;
|
||||
|
||||
skel = kfunc_call_test__open_and_load();
|
||||
skel = kfunc_call_test_lskel__open_and_load();
|
||||
if (!ASSERT_OK_PTR(skel, "skel"))
|
||||
return;
|
||||
|
||||
|
|
@ -26,7 +26,7 @@ static void test_main(void)
|
|||
ASSERT_OK(err, "bpf_prog_test_run(test2)");
|
||||
ASSERT_EQ(retval, 3, "test2-retval");
|
||||
|
||||
kfunc_call_test__destroy(skel);
|
||||
kfunc_call_test_lskel__destroy(skel);
|
||||
}
|
||||
|
||||
static void test_subprog(void)
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@
|
|||
#include "test_ksyms_btf.skel.h"
|
||||
#include "test_ksyms_btf_null_check.skel.h"
|
||||
#include "test_ksyms_weak.skel.h"
|
||||
#include "test_ksyms_weak.lskel.h"
|
||||
|
||||
static int duration;
|
||||
|
||||
|
|
@ -89,11 +90,11 @@ static void test_weak_syms(void)
|
|||
int err;
|
||||
|
||||
skel = test_ksyms_weak__open_and_load();
|
||||
if (CHECK(!skel, "test_ksyms_weak__open_and_load", "failed\n"))
|
||||
if (!ASSERT_OK_PTR(skel, "test_ksyms_weak__open_and_load"))
|
||||
return;
|
||||
|
||||
err = test_ksyms_weak__attach(skel);
|
||||
if (CHECK(err, "test_ksyms_weak__attach", "skeleton attach failed: %d\n", err))
|
||||
if (!ASSERT_OK(err, "test_ksyms_weak__attach"))
|
||||
goto cleanup;
|
||||
|
||||
/* trigger tracepoint */
|
||||
|
|
@ -109,6 +110,33 @@ cleanup:
|
|||
test_ksyms_weak__destroy(skel);
|
||||
}
|
||||
|
||||
static void test_weak_syms_lskel(void)
|
||||
{
|
||||
struct test_ksyms_weak_lskel *skel;
|
||||
struct test_ksyms_weak_lskel__data *data;
|
||||
int err;
|
||||
|
||||
skel = test_ksyms_weak_lskel__open_and_load();
|
||||
if (!ASSERT_OK_PTR(skel, "test_ksyms_weak_lskel__open_and_load"))
|
||||
return;
|
||||
|
||||
err = test_ksyms_weak_lskel__attach(skel);
|
||||
if (!ASSERT_OK(err, "test_ksyms_weak_lskel__attach"))
|
||||
goto cleanup;
|
||||
|
||||
/* trigger tracepoint */
|
||||
usleep(1);
|
||||
|
||||
data = skel->data;
|
||||
ASSERT_EQ(data->out__existing_typed, 0, "existing typed ksym");
|
||||
ASSERT_NEQ(data->out__existing_typeless, -1, "existing typeless ksym");
|
||||
ASSERT_EQ(data->out__non_existent_typeless, 0, "nonexistent typeless ksym");
|
||||
ASSERT_EQ(data->out__non_existent_typed, 0, "nonexistent typed ksym");
|
||||
|
||||
cleanup:
|
||||
test_ksyms_weak_lskel__destroy(skel);
|
||||
}
|
||||
|
||||
void test_ksyms_btf(void)
|
||||
{
|
||||
int percpu_datasec;
|
||||
|
|
@ -136,4 +164,7 @@ void test_ksyms_btf(void)
|
|||
|
||||
if (test__start_subtest("weak_ksyms"))
|
||||
test_weak_syms();
|
||||
|
||||
if (test__start_subtest("weak_ksyms_lskel"))
|
||||
test_weak_syms_lskel();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,30 +2,61 @@
|
|||
/* Copyright (c) 2021 Facebook */
|
||||
|
||||
#include <test_progs.h>
|
||||
#include <bpf/libbpf.h>
|
||||
#include <bpf/btf.h>
|
||||
#include <network_helpers.h>
|
||||
#include "test_ksyms_module.lskel.h"
|
||||
#include "test_ksyms_module.skel.h"
|
||||
|
||||
static int duration;
|
||||
|
||||
void test_ksyms_module(void)
|
||||
void test_ksyms_module_lskel(void)
|
||||
{
|
||||
struct test_ksyms_module* skel;
|
||||
struct test_ksyms_module_lskel *skel;
|
||||
int retval;
|
||||
int err;
|
||||
|
||||
skel = test_ksyms_module__open_and_load();
|
||||
if (CHECK(!skel, "skel_open", "failed to open skeleton\n"))
|
||||
if (!env.has_testmod) {
|
||||
test__skip();
|
||||
return;
|
||||
}
|
||||
|
||||
err = test_ksyms_module__attach(skel);
|
||||
if (CHECK(err, "skel_attach", "skeleton attach failed: %d\n", err))
|
||||
skel = test_ksyms_module_lskel__open_and_load();
|
||||
if (!ASSERT_OK_PTR(skel, "test_ksyms_module_lskel__open_and_load"))
|
||||
return;
|
||||
err = bpf_prog_test_run(skel->progs.load.prog_fd, 1, &pkt_v4, sizeof(pkt_v4),
|
||||
NULL, NULL, (__u32 *)&retval, NULL);
|
||||
if (!ASSERT_OK(err, "bpf_prog_test_run"))
|
||||
goto cleanup;
|
||||
ASSERT_EQ(retval, 0, "retval");
|
||||
ASSERT_EQ(skel->bss->out_bpf_testmod_ksym, 42, "bpf_testmod_ksym");
|
||||
cleanup:
|
||||
test_ksyms_module_lskel__destroy(skel);
|
||||
}
|
||||
|
||||
usleep(1);
|
||||
void test_ksyms_module_libbpf(void)
|
||||
{
|
||||
struct test_ksyms_module *skel;
|
||||
int retval, err;
|
||||
|
||||
ASSERT_EQ(skel->bss->triggered, true, "triggered");
|
||||
ASSERT_EQ(skel->bss->out_mod_ksym_global, 123, "global_ksym_val");
|
||||
if (!env.has_testmod) {
|
||||
test__skip();
|
||||
return;
|
||||
}
|
||||
|
||||
skel = test_ksyms_module__open_and_load();
|
||||
if (!ASSERT_OK_PTR(skel, "test_ksyms_module__open"))
|
||||
return;
|
||||
err = bpf_prog_test_run(bpf_program__fd(skel->progs.load), 1, &pkt_v4,
|
||||
sizeof(pkt_v4), NULL, NULL, (__u32 *)&retval, NULL);
|
||||
if (!ASSERT_OK(err, "bpf_prog_test_run"))
|
||||
goto cleanup;
|
||||
ASSERT_EQ(retval, 0, "retval");
|
||||
ASSERT_EQ(skel->bss->out_bpf_testmod_ksym, 42, "bpf_testmod_ksym");
|
||||
cleanup:
|
||||
test_ksyms_module__destroy(skel);
|
||||
}
|
||||
|
||||
void test_ksyms_module(void)
|
||||
{
|
||||
if (test__start_subtest("lskel"))
|
||||
test_ksyms_module_lskel();
|
||||
if (test__start_subtest("libbpf"))
|
||||
test_ksyms_module_libbpf();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -541,7 +541,7 @@ close_servers:
|
|||
}
|
||||
}
|
||||
|
||||
void test_migrate_reuseport(void)
|
||||
void serial_test_migrate_reuseport(void)
|
||||
{
|
||||
struct test_migrate_reuseport *skel;
|
||||
int i;
|
||||
|
|
|
|||
|
|
@ -53,7 +53,8 @@ cleanup:
|
|||
modify_return__destroy(skel);
|
||||
}
|
||||
|
||||
void test_modify_return(void)
|
||||
/* TODO: conflict with get_func_ip_test */
|
||||
void serial_test_modify_return(void)
|
||||
{
|
||||
run_test(0 /* input_retval */,
|
||||
1 /* want_side_effect */,
|
||||
|
|
|
|||
|
|
@ -2,46 +2,33 @@
|
|||
/* Copyright (c) 2020 Facebook */
|
||||
|
||||
#include <test_progs.h>
|
||||
#include <stdbool.h>
|
||||
#include "test_module_attach.skel.h"
|
||||
|
||||
static int duration;
|
||||
|
||||
static int trigger_module_test_read(int read_sz)
|
||||
static int trigger_module_test_writable(int *val)
|
||||
{
|
||||
int fd, err;
|
||||
char buf[65];
|
||||
ssize_t rd;
|
||||
|
||||
fd = open("/sys/kernel/bpf_testmod", O_RDONLY);
|
||||
fd = open(BPF_TESTMOD_TEST_FILE, O_RDONLY);
|
||||
err = -errno;
|
||||
if (CHECK(fd < 0, "testmod_file_open", "failed: %d\n", err))
|
||||
if (!ASSERT_GE(fd, 0, "testmode_file_open"))
|
||||
return err;
|
||||
|
||||
read(fd, NULL, read_sz);
|
||||
close(fd);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int trigger_module_test_write(int write_sz)
|
||||
{
|
||||
int fd, err;
|
||||
char *buf = malloc(write_sz);
|
||||
|
||||
if (!buf)
|
||||
return -ENOMEM;
|
||||
|
||||
memset(buf, 'a', write_sz);
|
||||
buf[write_sz-1] = '\0';
|
||||
|
||||
fd = open("/sys/kernel/bpf_testmod", O_WRONLY);
|
||||
rd = read(fd, buf, sizeof(buf) - 1);
|
||||
err = -errno;
|
||||
if (CHECK(fd < 0, "testmod_file_open", "failed: %d\n", err)) {
|
||||
free(buf);
|
||||
if (!ASSERT_GT(rd, 0, "testmod_file_rd_val")) {
|
||||
close(fd);
|
||||
return err;
|
||||
}
|
||||
|
||||
write(fd, buf, write_sz);
|
||||
buf[rd] = '\0';
|
||||
*val = strtol(buf, NULL, 0);
|
||||
close(fd);
|
||||
free(buf);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -58,6 +45,7 @@ void test_module_attach(void)
|
|||
struct test_module_attach__bss *bss;
|
||||
struct bpf_link *link;
|
||||
int err;
|
||||
int writable_val = 0;
|
||||
|
||||
skel = test_module_attach__open();
|
||||
if (CHECK(!skel, "skel_open", "failed to open skeleton\n"))
|
||||
|
|
@ -90,6 +78,14 @@ void test_module_attach(void)
|
|||
ASSERT_EQ(bss->fexit_ret, -EIO, "fexit_tet");
|
||||
ASSERT_EQ(bss->fmod_ret_read_sz, READ_SZ, "fmod_ret");
|
||||
|
||||
bss->raw_tp_writable_bare_early_ret = true;
|
||||
bss->raw_tp_writable_bare_out_val = 0xf1f2f3f4;
|
||||
ASSERT_OK(trigger_module_test_writable(&writable_val),
|
||||
"trigger_writable");
|
||||
ASSERT_EQ(bss->raw_tp_writable_bare_in_val, 1024, "writable_test_in");
|
||||
ASSERT_EQ(bss->raw_tp_writable_bare_out_val, writable_val,
|
||||
"writable_test_out");
|
||||
|
||||
test_module_attach__detach(skel);
|
||||
|
||||
/* attach fentry/fexit and make sure it get's module reference */
|
||||
|
|
|
|||
|
|
@ -78,7 +78,8 @@ static void test_ns_current_pid_tgid_new_ns(void)
|
|||
return;
|
||||
}
|
||||
|
||||
void test_ns_current_pid_tgid(void)
|
||||
/* TODO: use a different tracepoint */
|
||||
void serial_test_ns_current_pid_tgid(void)
|
||||
{
|
||||
if (test__start_subtest("ns_current_pid_tgid_root_ns"))
|
||||
test_current_pid_tgid(NULL);
|
||||
|
|
|
|||
|
|
@ -43,9 +43,10 @@ int trigger_on_cpu(int cpu)
|
|||
return 0;
|
||||
}
|
||||
|
||||
void test_perf_buffer(void)
|
||||
void serial_test_perf_buffer(void)
|
||||
{
|
||||
int err, on_len, nr_on_cpus = 0, nr_cpus, i;
|
||||
int err, on_len, nr_on_cpus = 0, nr_cpus, i, j;
|
||||
int zero = 0, my_pid = getpid();
|
||||
struct perf_buffer_opts pb_opts = {};
|
||||
struct test_perf_buffer *skel;
|
||||
cpu_set_t cpu_seen;
|
||||
|
|
@ -71,6 +72,10 @@ void test_perf_buffer(void)
|
|||
if (CHECK(!skel, "skel_load", "skeleton open/load failed\n"))
|
||||
goto out_close;
|
||||
|
||||
err = bpf_map_update_elem(bpf_map__fd(skel->maps.my_pid_map), &zero, &my_pid, 0);
|
||||
if (!ASSERT_OK(err, "my_pid_update"))
|
||||
goto out_close;
|
||||
|
||||
/* attach probe */
|
||||
err = test_perf_buffer__attach(skel);
|
||||
if (CHECK(err, "attach_kprobe", "err %d\n", err))
|
||||
|
|
@ -107,19 +112,19 @@ void test_perf_buffer(void)
|
|||
"expect %d, seen %d\n", nr_on_cpus, CPU_COUNT(&cpu_seen)))
|
||||
goto out_free_pb;
|
||||
|
||||
if (CHECK(perf_buffer__buffer_cnt(pb) != nr_cpus, "buf_cnt",
|
||||
"got %zu, expected %d\n", perf_buffer__buffer_cnt(pb), nr_cpus))
|
||||
if (CHECK(perf_buffer__buffer_cnt(pb) != nr_on_cpus, "buf_cnt",
|
||||
"got %zu, expected %d\n", perf_buffer__buffer_cnt(pb), nr_on_cpus))
|
||||
goto out_close;
|
||||
|
||||
for (i = 0; i < nr_cpus; i++) {
|
||||
for (i = 0, j = 0; i < nr_cpus; i++) {
|
||||
if (i >= on_len || !online[i])
|
||||
continue;
|
||||
|
||||
fd = perf_buffer__buffer_fd(pb, i);
|
||||
fd = perf_buffer__buffer_fd(pb, j);
|
||||
CHECK(fd < 0 || last_fd == fd, "fd_check", "last fd %d == fd %d\n", last_fd, fd);
|
||||
last_fd = fd;
|
||||
|
||||
err = perf_buffer__consume_buffer(pb, i);
|
||||
err = perf_buffer__consume_buffer(pb, j);
|
||||
if (CHECK(err, "drain_buf", "cpu %d, err %d\n", i, err))
|
||||
goto out_close;
|
||||
|
||||
|
|
@ -127,12 +132,13 @@ void test_perf_buffer(void)
|
|||
if (trigger_on_cpu(i))
|
||||
goto out_close;
|
||||
|
||||
err = perf_buffer__consume_buffer(pb, i);
|
||||
if (CHECK(err, "consume_buf", "cpu %d, err %d\n", i, err))
|
||||
err = perf_buffer__consume_buffer(pb, j);
|
||||
if (CHECK(err, "consume_buf", "cpu %d, err %d\n", j, err))
|
||||
goto out_close;
|
||||
|
||||
if (CHECK(!CPU_ISSET(i, &cpu_seen), "cpu_seen", "cpu %d not seen\n", i))
|
||||
goto out_close;
|
||||
j++;
|
||||
}
|
||||
|
||||
out_free_pb:
|
||||
|
|
|
|||
|
|
@ -23,7 +23,8 @@ static void burn_cpu(void)
|
|||
++j;
|
||||
}
|
||||
|
||||
void test_perf_link(void)
|
||||
/* TODO: often fails in concurrent mode */
|
||||
void serial_test_perf_link(void)
|
||||
{
|
||||
struct test_perf_link *skel = NULL;
|
||||
struct perf_event_attr attr;
|
||||
|
|
|
|||
|
|
@ -1,9 +1,10 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
#include <test_progs.h>
|
||||
|
||||
void test_probe_user(void)
|
||||
/* TODO: corrupts other tests uses connect() */
|
||||
void serial_test_probe_user(void)
|
||||
{
|
||||
const char *prog_name = "kprobe/__sys_connect";
|
||||
const char *prog_name = "handle_sys_connect";
|
||||
const char *obj_file = "./test_probe_user.o";
|
||||
DECLARE_LIBBPF_OPTS(bpf_object_open_opts, opts, );
|
||||
int err, results_map_fd, sock_fd, duration = 0;
|
||||
|
|
@ -18,7 +19,7 @@ void test_probe_user(void)
|
|||
if (!ASSERT_OK_PTR(obj, "obj_open_file"))
|
||||
return;
|
||||
|
||||
kprobe_prog = bpf_object__find_program_by_title(obj, prog_name);
|
||||
kprobe_prog = bpf_object__find_program_by_name(obj, prog_name);
|
||||
if (CHECK(!kprobe_prog, "find_probe",
|
||||
"prog '%s' not found\n", prog_name))
|
||||
goto cleanup;
|
||||
|
|
|
|||
|
|
@ -3,7 +3,8 @@
|
|||
#include <test_progs.h>
|
||||
#include <linux/nbd.h>
|
||||
|
||||
void test_raw_tp_writable_test_run(void)
|
||||
/* NOTE: conflict with other tests. */
|
||||
void serial_test_raw_tp_writable_test_run(void)
|
||||
{
|
||||
__u32 duration = 0;
|
||||
char error[4096];
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ void test_rdonly_maps(void)
|
|||
if (CHECK(err, "obj_load", "err %d errno %d\n", err, errno))
|
||||
goto cleanup;
|
||||
|
||||
bss_map = bpf_object__find_map_by_name(obj, "test_rdo.bss");
|
||||
bss_map = bpf_object__find_map_by_name(obj, ".bss");
|
||||
if (CHECK(!bss_map, "find_bss_map", "failed\n"))
|
||||
goto cleanup;
|
||||
|
||||
|
|
|
|||
|
|
@ -20,18 +20,18 @@ void test_recursion(void)
|
|||
goto out;
|
||||
|
||||
ASSERT_EQ(skel->bss->pass1, 0, "pass1 == 0");
|
||||
bpf_map_lookup_elem(bpf_map__fd(skel->maps.hash1), &key, 0);
|
||||
bpf_map_delete_elem(bpf_map__fd(skel->maps.hash1), &key);
|
||||
ASSERT_EQ(skel->bss->pass1, 1, "pass1 == 1");
|
||||
bpf_map_lookup_elem(bpf_map__fd(skel->maps.hash1), &key, 0);
|
||||
bpf_map_delete_elem(bpf_map__fd(skel->maps.hash1), &key);
|
||||
ASSERT_EQ(skel->bss->pass1, 2, "pass1 == 2");
|
||||
|
||||
ASSERT_EQ(skel->bss->pass2, 0, "pass2 == 0");
|
||||
bpf_map_lookup_elem(bpf_map__fd(skel->maps.hash2), &key, 0);
|
||||
bpf_map_delete_elem(bpf_map__fd(skel->maps.hash2), &key);
|
||||
ASSERT_EQ(skel->bss->pass2, 1, "pass2 == 1");
|
||||
bpf_map_lookup_elem(bpf_map__fd(skel->maps.hash2), &key, 0);
|
||||
bpf_map_delete_elem(bpf_map__fd(skel->maps.hash2), &key);
|
||||
ASSERT_EQ(skel->bss->pass2, 2, "pass2 == 2");
|
||||
|
||||
err = bpf_obj_get_info_by_fd(bpf_program__fd(skel->progs.on_lookup),
|
||||
err = bpf_obj_get_info_by_fd(bpf_program__fd(skel->progs.on_delete),
|
||||
&prog_info, &prog_info_len);
|
||||
if (!ASSERT_OK(err, "get_prog_info"))
|
||||
goto out;
|
||||
|
|
|
|||
|
|
@ -1,6 +1,21 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
#include <test_progs.h>
|
||||
|
||||
static void toggle_object_autoload_progs(const struct bpf_object *obj,
|
||||
const char *name_load)
|
||||
{
|
||||
struct bpf_program *prog;
|
||||
|
||||
bpf_object__for_each_program(prog, obj) {
|
||||
const char *name = bpf_program__name(prog);
|
||||
|
||||
if (!strcmp(name_load, name))
|
||||
bpf_program__set_autoload(prog, true);
|
||||
else
|
||||
bpf_program__set_autoload(prog, false);
|
||||
}
|
||||
}
|
||||
|
||||
void test_reference_tracking(void)
|
||||
{
|
||||
const char *file = "test_sk_lookup_kern.o";
|
||||
|
|
@ -9,44 +24,49 @@ void test_reference_tracking(void)
|
|||
.object_name = obj_name,
|
||||
.relaxed_maps = true,
|
||||
);
|
||||
struct bpf_object *obj;
|
||||
struct bpf_object *obj_iter, *obj = NULL;
|
||||
struct bpf_program *prog;
|
||||
__u32 duration = 0;
|
||||
int err = 0;
|
||||
|
||||
obj = bpf_object__open_file(file, &open_opts);
|
||||
if (!ASSERT_OK_PTR(obj, "obj_open_file"))
|
||||
obj_iter = bpf_object__open_file(file, &open_opts);
|
||||
if (!ASSERT_OK_PTR(obj_iter, "obj_iter_open_file"))
|
||||
return;
|
||||
|
||||
if (CHECK(strcmp(bpf_object__name(obj), obj_name), "obj_name",
|
||||
if (CHECK(strcmp(bpf_object__name(obj_iter), obj_name), "obj_name",
|
||||
"wrong obj name '%s', expected '%s'\n",
|
||||
bpf_object__name(obj), obj_name))
|
||||
bpf_object__name(obj_iter), obj_name))
|
||||
goto cleanup;
|
||||
|
||||
bpf_object__for_each_program(prog, obj) {
|
||||
const char *title;
|
||||
bpf_object__for_each_program(prog, obj_iter) {
|
||||
const char *name;
|
||||
|
||||
/* Ignore .text sections */
|
||||
title = bpf_program__section_name(prog);
|
||||
if (strstr(title, ".text") != NULL)
|
||||
name = bpf_program__name(prog);
|
||||
if (!test__start_subtest(name))
|
||||
continue;
|
||||
|
||||
if (!test__start_subtest(title))
|
||||
continue;
|
||||
obj = bpf_object__open_file(file, &open_opts);
|
||||
if (!ASSERT_OK_PTR(obj, "obj_open_file"))
|
||||
goto cleanup;
|
||||
|
||||
toggle_object_autoload_progs(obj, name);
|
||||
/* Expect verifier failure if test name has 'err' */
|
||||
if (strstr(title, "err_") != NULL) {
|
||||
if (strncmp(name, "err_", sizeof("err_") - 1) == 0) {
|
||||
libbpf_print_fn_t old_print_fn;
|
||||
|
||||
old_print_fn = libbpf_set_print(NULL);
|
||||
err = !bpf_program__load(prog, "GPL", 0);
|
||||
err = !bpf_object__load(obj);
|
||||
libbpf_set_print(old_print_fn);
|
||||
} else {
|
||||
err = bpf_program__load(prog, "GPL", 0);
|
||||
err = bpf_object__load(obj);
|
||||
}
|
||||
CHECK(err, title, "\n");
|
||||
ASSERT_OK(err, name);
|
||||
|
||||
bpf_object__close(obj);
|
||||
obj = NULL;
|
||||
}
|
||||
|
||||
cleanup:
|
||||
bpf_object__close(obj);
|
||||
bpf_object__close(obj_iter);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -106,9 +106,9 @@ static int resolve_symbols(void)
|
|||
"Failed to load BTF from btf_data.o\n"))
|
||||
return -1;
|
||||
|
||||
nr = btf__get_nr_types(btf);
|
||||
nr = btf__type_cnt(btf);
|
||||
|
||||
for (type_id = 1; type_id <= nr; type_id++) {
|
||||
for (type_id = 1; type_id < nr; type_id++) {
|
||||
if (__resolve_symbol(btf, type_id))
|
||||
break;
|
||||
}
|
||||
|
|
@ -117,14 +117,14 @@ static int resolve_symbols(void)
|
|||
return 0;
|
||||
}
|
||||
|
||||
int test_resolve_btfids(void)
|
||||
void test_resolve_btfids(void)
|
||||
{
|
||||
__u32 *test_list, *test_lists[] = { test_list_local, test_list_global };
|
||||
unsigned int i, j;
|
||||
int ret = 0;
|
||||
|
||||
if (resolve_symbols())
|
||||
return -1;
|
||||
return;
|
||||
|
||||
/* Check BTF_ID_LIST(test_list_local) and
|
||||
* BTF_ID_LIST_GLOBAL(test_list_global) IDs
|
||||
|
|
@ -138,7 +138,7 @@ int test_resolve_btfids(void)
|
|||
test_symbols[i].name,
|
||||
test_list[i], test_symbols[i].id);
|
||||
if (ret)
|
||||
return ret;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -161,9 +161,7 @@ int test_resolve_btfids(void)
|
|||
|
||||
if (i > 0) {
|
||||
if (!ASSERT_LE(test_set.ids[i - 1], test_set.ids[i], "sort_check"))
|
||||
return -1;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ static int process_sample(void *ctx, void *data, size_t len)
|
|||
}
|
||||
}
|
||||
|
||||
static struct test_ringbuf *skel;
|
||||
static struct test_ringbuf_lskel *skel;
|
||||
static struct ring_buffer *ringbuf;
|
||||
|
||||
static void trigger_samples()
|
||||
|
|
@ -90,13 +90,13 @@ void test_ringbuf(void)
|
|||
int page_size = getpagesize();
|
||||
void *mmap_ptr, *tmp_ptr;
|
||||
|
||||
skel = test_ringbuf__open();
|
||||
skel = test_ringbuf_lskel__open();
|
||||
if (CHECK(!skel, "skel_open", "skeleton open failed\n"))
|
||||
return;
|
||||
|
||||
skel->maps.ringbuf.max_entries = page_size;
|
||||
|
||||
err = test_ringbuf__load(skel);
|
||||
err = test_ringbuf_lskel__load(skel);
|
||||
if (CHECK(err != 0, "skel_load", "skeleton load failed\n"))
|
||||
goto cleanup;
|
||||
|
||||
|
|
@ -154,7 +154,7 @@ void test_ringbuf(void)
|
|||
if (CHECK(!ringbuf, "ringbuf_create", "failed to create ringbuf\n"))
|
||||
goto cleanup;
|
||||
|
||||
err = test_ringbuf__attach(skel);
|
||||
err = test_ringbuf_lskel__attach(skel);
|
||||
if (CHECK(err, "skel_attach", "skeleton attachment failed: %d\n", err))
|
||||
goto cleanup;
|
||||
|
||||
|
|
@ -292,8 +292,8 @@ void test_ringbuf(void)
|
|||
CHECK(skel->bss->discarded != 1, "err_discarded", "exp %ld, got %ld\n",
|
||||
1L, skel->bss->discarded);
|
||||
|
||||
test_ringbuf__detach(skel);
|
||||
test_ringbuf_lskel__detach(skel);
|
||||
cleanup:
|
||||
ring_buffer__free(ringbuf);
|
||||
test_ringbuf__destroy(skel);
|
||||
test_ringbuf_lskel__destroy(skel);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -114,7 +114,7 @@ static int prepare_bpf_obj(void)
|
|||
err = bpf_object__load(obj);
|
||||
RET_ERR(err, "load bpf_object", "err:%d\n", err);
|
||||
|
||||
prog = bpf_program__next(NULL, obj);
|
||||
prog = bpf_object__next_program(obj, NULL);
|
||||
RET_ERR(!prog, "get first bpf_program", "!prog\n");
|
||||
select_by_skb_data_prog = bpf_program__fd(prog);
|
||||
RET_ERR(select_by_skb_data_prog < 0, "get prog fd",
|
||||
|
|
@ -858,7 +858,7 @@ out:
|
|||
cleanup();
|
||||
}
|
||||
|
||||
void test_select_reuseport(void)
|
||||
void serial_test_select_reuseport(void)
|
||||
{
|
||||
saved_tcp_fo = read_int_sysctl(TCP_FO_SYSCTL);
|
||||
if (saved_tcp_fo < 0)
|
||||
|
|
|
|||
|
|
@ -25,7 +25,8 @@ static void *worker(void *p)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
void test_send_signal_sched_switch(void)
|
||||
/* NOTE: cause events loss */
|
||||
void serial_test_send_signal_sched_switch(void)
|
||||
{
|
||||
struct test_send_signal_kern *skel;
|
||||
pthread_t threads[THREAD_COUNT];
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ static void test_signal_pending_by_type(enum bpf_prog_type prog_type)
|
|||
signal(SIGALRM, SIG_DFL);
|
||||
}
|
||||
|
||||
void test_signal_pending(enum bpf_prog_type prog_type)
|
||||
void test_signal_pending(void)
|
||||
{
|
||||
test_signal_pending_by_type(BPF_PROG_TYPE_SOCKET_FILTER);
|
||||
test_signal_pending_by_type(BPF_PROG_TYPE_FLOW_DISSECTOR);
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ configure_stack(void)
|
|||
return false;
|
||||
sprintf(tc_cmd, "%s %s %s %s", "tc filter add dev lo ingress bpf",
|
||||
"direct-action object-file ./test_sk_assign.o",
|
||||
"section classifier/sk_assign_test",
|
||||
"section tc",
|
||||
(env.verbosity < VERBOSE_VERY) ? " 2>/dev/null" : "verbose");
|
||||
if (CHECK(system(tc_cmd), "BPF load failed;",
|
||||
"run with -vv for more info\n"))
|
||||
|
|
|
|||
|
|
@ -598,7 +598,7 @@ close:
|
|||
|
||||
static void run_lookup_prog(const struct test *t)
|
||||
{
|
||||
int server_fds[MAX_SERVERS] = { -1 };
|
||||
int server_fds[] = { [0 ... MAX_SERVERS - 1] = -1 };
|
||||
int client_fd, reuse_conn_fd = -1;
|
||||
struct bpf_link *lookup_link;
|
||||
int i, err;
|
||||
|
|
@ -1053,7 +1053,7 @@ static void run_sk_assign(struct test_sk_lookup *skel,
|
|||
struct bpf_program *lookup_prog,
|
||||
const char *remote_ip, const char *local_ip)
|
||||
{
|
||||
int server_fds[MAX_SERVERS] = { -1 };
|
||||
int server_fds[] = { [0 ... MAX_SERVERS - 1] = -1 };
|
||||
struct bpf_sk_lookup ctx;
|
||||
__u64 server_cookie;
|
||||
int i, err;
|
||||
|
|
|
|||
|
|
@ -105,7 +105,7 @@ out:
|
|||
close(listen_fd);
|
||||
}
|
||||
|
||||
void test_sk_storage_tracing(void)
|
||||
void serial_test_sk_storage_tracing(void)
|
||||
{
|
||||
struct test_sk_storage_trace_itself *skel_itself;
|
||||
int err;
|
||||
|
|
|
|||
|
|
@ -11,12 +11,14 @@ void test_skb_ctx(void)
|
|||
.cb[3] = 4,
|
||||
.cb[4] = 5,
|
||||
.priority = 6,
|
||||
.ingress_ifindex = 11,
|
||||
.ifindex = 1,
|
||||
.tstamp = 7,
|
||||
.wire_len = 100,
|
||||
.gso_segs = 8,
|
||||
.mark = 9,
|
||||
.gso_size = 10,
|
||||
.hwtstamp = 11,
|
||||
};
|
||||
struct bpf_prog_test_run_attr tattr = {
|
||||
.data_in = &pkt_v4,
|
||||
|
|
@ -97,6 +99,10 @@ void test_skb_ctx(void)
|
|||
"ctx_out_ifindex",
|
||||
"skb->ifindex == %d, expected %d\n",
|
||||
skb.ifindex, 1);
|
||||
CHECK_ATTR(skb.ingress_ifindex != 11,
|
||||
"ctx_out_ingress_ifindex",
|
||||
"skb->ingress_ifindex == %d, expected %d\n",
|
||||
skb.ingress_ifindex, 11);
|
||||
CHECK_ATTR(skb.tstamp != 8,
|
||||
"ctx_out_tstamp",
|
||||
"skb->tstamp == %lld, expected %d\n",
|
||||
|
|
|
|||
54
tools/testing/selftests/bpf/prog_tests/skc_to_unix_sock.c
Normal file
54
tools/testing/selftests/bpf/prog_tests/skc_to_unix_sock.c
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 */
|
||||
/* Copyright (c) 2021 Hengqi Chen */
|
||||
|
||||
#include <test_progs.h>
|
||||
#include <sys/un.h>
|
||||
#include "test_skc_to_unix_sock.skel.h"
|
||||
|
||||
static const char *sock_path = "@skc_to_unix_sock";
|
||||
|
||||
void test_skc_to_unix_sock(void)
|
||||
{
|
||||
struct test_skc_to_unix_sock *skel;
|
||||
struct sockaddr_un sockaddr;
|
||||
int err, sockfd = 0;
|
||||
|
||||
skel = test_skc_to_unix_sock__open();
|
||||
if (!ASSERT_OK_PTR(skel, "could not open BPF object"))
|
||||
return;
|
||||
|
||||
skel->rodata->my_pid = getpid();
|
||||
|
||||
err = test_skc_to_unix_sock__load(skel);
|
||||
if (!ASSERT_OK(err, "could not load BPF object"))
|
||||
goto cleanup;
|
||||
|
||||
err = test_skc_to_unix_sock__attach(skel);
|
||||
if (!ASSERT_OK(err, "could not attach BPF object"))
|
||||
goto cleanup;
|
||||
|
||||
/* trigger unix_listen */
|
||||
sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
|
||||
if (!ASSERT_GT(sockfd, 0, "socket failed"))
|
||||
goto cleanup;
|
||||
|
||||
memset(&sockaddr, 0, sizeof(sockaddr));
|
||||
sockaddr.sun_family = AF_UNIX;
|
||||
strncpy(sockaddr.sun_path, sock_path, strlen(sock_path));
|
||||
sockaddr.sun_path[0] = '\0';
|
||||
|
||||
err = bind(sockfd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
|
||||
if (!ASSERT_OK(err, "bind failed"))
|
||||
goto cleanup;
|
||||
|
||||
err = listen(sockfd, 1);
|
||||
if (!ASSERT_OK(err, "listen failed"))
|
||||
goto cleanup;
|
||||
|
||||
ASSERT_EQ(strcmp(skel->bss->path, sock_path), 0, "bpf_skc_to_unix_sock failed");
|
||||
|
||||
cleanup:
|
||||
if (sockfd)
|
||||
close(sockfd);
|
||||
test_skc_to_unix_sock__destroy(skel);
|
||||
}
|
||||
|
|
@ -16,8 +16,13 @@ void test_skeleton(void)
|
|||
struct test_skeleton* skel;
|
||||
struct test_skeleton__bss *bss;
|
||||
struct test_skeleton__data *data;
|
||||
struct test_skeleton__data_dyn *data_dyn;
|
||||
struct test_skeleton__rodata *rodata;
|
||||
struct test_skeleton__rodata_dyn *rodata_dyn;
|
||||
struct test_skeleton__kconfig *kcfg;
|
||||
const void *elf_bytes;
|
||||
size_t elf_bytes_sz = 0;
|
||||
int i;
|
||||
|
||||
skel = test_skeleton__open();
|
||||
if (CHECK(!skel, "skel_open", "failed to open skeleton\n"))
|
||||
|
|
@ -28,7 +33,12 @@ void test_skeleton(void)
|
|||
|
||||
bss = skel->bss;
|
||||
data = skel->data;
|
||||
data_dyn = skel->data_dyn;
|
||||
rodata = skel->rodata;
|
||||
rodata_dyn = skel->rodata_dyn;
|
||||
|
||||
ASSERT_STREQ(bpf_map__name(skel->maps.rodata_dyn), ".rodata.dyn", "rodata_dyn_name");
|
||||
ASSERT_STREQ(bpf_map__name(skel->maps.data_dyn), ".data.dyn", "data_dyn_name");
|
||||
|
||||
/* validate values are pre-initialized correctly */
|
||||
CHECK(data->in1 != -1, "in1", "got %d != exp %d\n", data->in1, -1);
|
||||
|
|
@ -44,6 +54,12 @@ void test_skeleton(void)
|
|||
CHECK(rodata->in.in6 != 0, "in6", "got %d != exp %d\n", rodata->in.in6, 0);
|
||||
CHECK(bss->out6 != 0, "out6", "got %d != exp %d\n", bss->out6, 0);
|
||||
|
||||
ASSERT_EQ(rodata_dyn->in_dynarr_sz, 0, "in_dynarr_sz");
|
||||
for (i = 0; i < 4; i++)
|
||||
ASSERT_EQ(rodata_dyn->in_dynarr[i], -(i + 1), "in_dynarr");
|
||||
for (i = 0; i < 4; i++)
|
||||
ASSERT_EQ(data_dyn->out_dynarr[i], i + 1, "out_dynarr");
|
||||
|
||||
/* validate we can pre-setup global variables, even in .bss */
|
||||
data->in1 = 10;
|
||||
data->in2 = 11;
|
||||
|
|
@ -51,6 +67,10 @@ void test_skeleton(void)
|
|||
bss->in4 = 13;
|
||||
rodata->in.in6 = 14;
|
||||
|
||||
rodata_dyn->in_dynarr_sz = 4;
|
||||
for (i = 0; i < 4; i++)
|
||||
rodata_dyn->in_dynarr[i] = i + 10;
|
||||
|
||||
err = test_skeleton__load(skel);
|
||||
if (CHECK(err, "skel_load", "failed to load skeleton: %d\n", err))
|
||||
goto cleanup;
|
||||
|
|
@ -62,6 +82,10 @@ void test_skeleton(void)
|
|||
CHECK(bss->in4 != 13, "in4", "got %lld != exp %lld\n", bss->in4, 13LL);
|
||||
CHECK(rodata->in.in6 != 14, "in6", "got %d != exp %d\n", rodata->in.in6, 14);
|
||||
|
||||
ASSERT_EQ(rodata_dyn->in_dynarr_sz, 4, "in_dynarr_sz");
|
||||
for (i = 0; i < 4; i++)
|
||||
ASSERT_EQ(rodata_dyn->in_dynarr[i], i + 10, "in_dynarr");
|
||||
|
||||
/* now set new values and attach to get them into outX variables */
|
||||
data->in1 = 1;
|
||||
data->in2 = 2;
|
||||
|
|
@ -71,6 +95,8 @@ void test_skeleton(void)
|
|||
bss->in5.b = 6;
|
||||
kcfg = skel->kconfig;
|
||||
|
||||
skel->data_read_mostly->read_mostly_var = 123;
|
||||
|
||||
err = test_skeleton__attach(skel);
|
||||
if (CHECK(err, "skel_attach", "skeleton attach failed: %d\n", err))
|
||||
goto cleanup;
|
||||
|
|
@ -91,6 +117,15 @@ void test_skeleton(void)
|
|||
CHECK(bss->kern_ver != kcfg->LINUX_KERNEL_VERSION, "ext2",
|
||||
"got %d != exp %d\n", bss->kern_ver, kcfg->LINUX_KERNEL_VERSION);
|
||||
|
||||
for (i = 0; i < 4; i++)
|
||||
ASSERT_EQ(data_dyn->out_dynarr[i], i + 10, "out_dynarr");
|
||||
|
||||
ASSERT_EQ(skel->bss->out_mostly_var, 123, "out_mostly_var");
|
||||
|
||||
elf_bytes = test_skeleton__elf_bytes(&elf_bytes_sz);
|
||||
ASSERT_OK_PTR(elf_bytes, "elf_bytes");
|
||||
ASSERT_GE(elf_bytes_sz, 0, "elf_bytes_sz");
|
||||
|
||||
cleanup:
|
||||
test_skeleton__destroy(skel);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@
|
|||
|
||||
#define EXP_NO_BUF_RET 29
|
||||
|
||||
void test_snprintf_positive(void)
|
||||
static void test_snprintf_positive(void)
|
||||
{
|
||||
char exp_addr_out[] = EXP_ADDR_OUT;
|
||||
char exp_sym_out[] = EXP_SYM_OUT;
|
||||
|
|
@ -103,7 +103,7 @@ static int load_single_snprintf(char *fmt)
|
|||
return ret;
|
||||
}
|
||||
|
||||
void test_snprintf_negative(void)
|
||||
static void test_snprintf_negative(void)
|
||||
{
|
||||
ASSERT_OK(load_single_snprintf("valid %d"), "valid usage");
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
/* Demonstrate that bpf_snprintf_btf succeeds and that various data types
|
||||
* are formatted correctly.
|
||||
*/
|
||||
void test_snprintf_btf(void)
|
||||
void serial_test_snprintf_btf(void)
|
||||
{
|
||||
struct netif_receive_skb *skel;
|
||||
struct netif_receive_skb__bss *bss;
|
||||
|
|
|
|||
|
|
@ -329,7 +329,7 @@ done:
|
|||
close(listen_fd);
|
||||
}
|
||||
|
||||
void test_sock_fields(void)
|
||||
void serial_test_sock_fields(void)
|
||||
{
|
||||
struct bpf_link *egress_link = NULL, *ingress_link = NULL;
|
||||
int parent_cg_fd = -1, child_cg_fd = -1;
|
||||
|
|
|
|||
|
|
@ -2002,7 +2002,7 @@ static void run_tests(struct test_sockmap_listen *skel, struct bpf_map *map,
|
|||
test_udp_unix_redir(skel, map, family);
|
||||
}
|
||||
|
||||
void test_sockmap_listen(void)
|
||||
void serial_test_sockmap_listen(void)
|
||||
{
|
||||
struct test_sockmap_listen *skel;
|
||||
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
#include <test_progs.h>
|
||||
#include "cgroup_helpers.h"
|
||||
|
||||
static int prog_attach(struct bpf_object *obj, int cgroup_fd, const char *title)
|
||||
static int prog_attach(struct bpf_object *obj, int cgroup_fd, const char *title, const char *name)
|
||||
{
|
||||
enum bpf_attach_type attach_type;
|
||||
enum bpf_prog_type prog_type;
|
||||
|
|
@ -15,23 +15,23 @@ static int prog_attach(struct bpf_object *obj, int cgroup_fd, const char *title)
|
|||
return -1;
|
||||
}
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, title);
|
||||
prog = bpf_object__find_program_by_name(obj, name);
|
||||
if (!prog) {
|
||||
log_err("Failed to find %s BPF program", title);
|
||||
log_err("Failed to find %s BPF program", name);
|
||||
return -1;
|
||||
}
|
||||
|
||||
err = bpf_prog_attach(bpf_program__fd(prog), cgroup_fd,
|
||||
attach_type, BPF_F_ALLOW_MULTI);
|
||||
if (err) {
|
||||
log_err("Failed to attach %s BPF program", title);
|
||||
log_err("Failed to attach %s BPF program", name);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int prog_detach(struct bpf_object *obj, int cgroup_fd, const char *title)
|
||||
static int prog_detach(struct bpf_object *obj, int cgroup_fd, const char *title, const char *name)
|
||||
{
|
||||
enum bpf_attach_type attach_type;
|
||||
enum bpf_prog_type prog_type;
|
||||
|
|
@ -42,7 +42,7 @@ static int prog_detach(struct bpf_object *obj, int cgroup_fd, const char *title)
|
|||
if (err)
|
||||
return -1;
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, title);
|
||||
prog = bpf_object__find_program_by_name(obj, name);
|
||||
if (!prog)
|
||||
return -1;
|
||||
|
||||
|
|
@ -89,7 +89,7 @@ static int run_getsockopt_test(struct bpf_object *obj, int cg_parent,
|
|||
* - child: 0x80 -> 0x90
|
||||
*/
|
||||
|
||||
err = prog_attach(obj, cg_child, "cgroup/getsockopt/child");
|
||||
err = prog_attach(obj, cg_child, "cgroup/getsockopt", "_getsockopt_child");
|
||||
if (err)
|
||||
goto detach;
|
||||
|
||||
|
|
@ -113,7 +113,7 @@ static int run_getsockopt_test(struct bpf_object *obj, int cg_parent,
|
|||
* - parent: 0x90 -> 0xA0
|
||||
*/
|
||||
|
||||
err = prog_attach(obj, cg_parent, "cgroup/getsockopt/parent");
|
||||
err = prog_attach(obj, cg_parent, "cgroup/getsockopt", "_getsockopt_parent");
|
||||
if (err)
|
||||
goto detach;
|
||||
|
||||
|
|
@ -157,7 +157,7 @@ static int run_getsockopt_test(struct bpf_object *obj, int cg_parent,
|
|||
* - parent: unexpected 0x40, EPERM
|
||||
*/
|
||||
|
||||
err = prog_detach(obj, cg_child, "cgroup/getsockopt/child");
|
||||
err = prog_detach(obj, cg_child, "cgroup/getsockopt", "_getsockopt_child");
|
||||
if (err) {
|
||||
log_err("Failed to detach child program");
|
||||
goto detach;
|
||||
|
|
@ -198,8 +198,8 @@ static int run_getsockopt_test(struct bpf_object *obj, int cg_parent,
|
|||
}
|
||||
|
||||
detach:
|
||||
prog_detach(obj, cg_child, "cgroup/getsockopt/child");
|
||||
prog_detach(obj, cg_parent, "cgroup/getsockopt/parent");
|
||||
prog_detach(obj, cg_child, "cgroup/getsockopt", "_getsockopt_child");
|
||||
prog_detach(obj, cg_parent, "cgroup/getsockopt", "_getsockopt_parent");
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
@ -236,7 +236,7 @@ static int run_setsockopt_test(struct bpf_object *obj, int cg_parent,
|
|||
|
||||
/* Attach child program and make sure it adds 0x10. */
|
||||
|
||||
err = prog_attach(obj, cg_child, "cgroup/setsockopt");
|
||||
err = prog_attach(obj, cg_child, "cgroup/setsockopt", "_setsockopt");
|
||||
if (err)
|
||||
goto detach;
|
||||
|
||||
|
|
@ -263,7 +263,7 @@ static int run_setsockopt_test(struct bpf_object *obj, int cg_parent,
|
|||
|
||||
/* Attach parent program and make sure it adds another 0x10. */
|
||||
|
||||
err = prog_attach(obj, cg_parent, "cgroup/setsockopt");
|
||||
err = prog_attach(obj, cg_parent, "cgroup/setsockopt", "_setsockopt");
|
||||
if (err)
|
||||
goto detach;
|
||||
|
||||
|
|
@ -289,8 +289,8 @@ static int run_setsockopt_test(struct bpf_object *obj, int cg_parent,
|
|||
}
|
||||
|
||||
detach:
|
||||
prog_detach(obj, cg_child, "cgroup/setsockopt");
|
||||
prog_detach(obj, cg_parent, "cgroup/setsockopt");
|
||||
prog_detach(obj, cg_child, "cgroup/setsockopt", "_setsockopt");
|
||||
prog_detach(obj, cg_parent, "cgroup/setsockopt", "_setsockopt");
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ static void test_tailcall_1(void)
|
|||
if (CHECK_FAIL(err))
|
||||
return;
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, "classifier");
|
||||
prog = bpf_object__find_program_by_name(obj, "entry");
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -38,9 +38,9 @@ static void test_tailcall_1(void)
|
|||
goto out;
|
||||
|
||||
for (i = 0; i < bpf_map__def(prog_array)->max_entries; i++) {
|
||||
snprintf(prog_name, sizeof(prog_name), "classifier/%i", i);
|
||||
snprintf(prog_name, sizeof(prog_name), "classifier_%d", i);
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, prog_name);
|
||||
prog = bpf_object__find_program_by_name(obj, prog_name);
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -70,9 +70,9 @@ static void test_tailcall_1(void)
|
|||
err, errno, retval);
|
||||
|
||||
for (i = 0; i < bpf_map__def(prog_array)->max_entries; i++) {
|
||||
snprintf(prog_name, sizeof(prog_name), "classifier/%i", i);
|
||||
snprintf(prog_name, sizeof(prog_name), "classifier_%d", i);
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, prog_name);
|
||||
prog = bpf_object__find_program_by_name(obj, prog_name);
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -92,9 +92,9 @@ static void test_tailcall_1(void)
|
|||
|
||||
for (i = 0; i < bpf_map__def(prog_array)->max_entries; i++) {
|
||||
j = bpf_map__def(prog_array)->max_entries - 1 - i;
|
||||
snprintf(prog_name, sizeof(prog_name), "classifier/%i", j);
|
||||
snprintf(prog_name, sizeof(prog_name), "classifier_%d", j);
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, prog_name);
|
||||
prog = bpf_object__find_program_by_name(obj, prog_name);
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -159,7 +159,7 @@ static void test_tailcall_2(void)
|
|||
if (CHECK_FAIL(err))
|
||||
return;
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, "classifier");
|
||||
prog = bpf_object__find_program_by_name(obj, "entry");
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -176,9 +176,9 @@ static void test_tailcall_2(void)
|
|||
goto out;
|
||||
|
||||
for (i = 0; i < bpf_map__def(prog_array)->max_entries; i++) {
|
||||
snprintf(prog_name, sizeof(prog_name), "classifier/%i", i);
|
||||
snprintf(prog_name, sizeof(prog_name), "classifier_%d", i);
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, prog_name);
|
||||
prog = bpf_object__find_program_by_name(obj, prog_name);
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -219,10 +219,7 @@ out:
|
|||
bpf_object__close(obj);
|
||||
}
|
||||
|
||||
/* test_tailcall_3 checks that the count value of the tail call limit
|
||||
* enforcement matches with expectations.
|
||||
*/
|
||||
static void test_tailcall_3(void)
|
||||
static void test_tailcall_count(const char *which)
|
||||
{
|
||||
int err, map_fd, prog_fd, main_fd, data_fd, i, val;
|
||||
struct bpf_map *prog_array, *data_map;
|
||||
|
|
@ -231,12 +228,12 @@ static void test_tailcall_3(void)
|
|||
__u32 retval, duration;
|
||||
char buff[128] = {};
|
||||
|
||||
err = bpf_prog_load("tailcall3.o", BPF_PROG_TYPE_SCHED_CLS, &obj,
|
||||
err = bpf_prog_load(which, BPF_PROG_TYPE_SCHED_CLS, &obj,
|
||||
&prog_fd);
|
||||
if (CHECK_FAIL(err))
|
||||
return;
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, "classifier");
|
||||
prog = bpf_object__find_program_by_name(obj, "entry");
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -252,7 +249,7 @@ static void test_tailcall_3(void)
|
|||
if (CHECK_FAIL(map_fd < 0))
|
||||
goto out;
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, "classifier/0");
|
||||
prog = bpf_object__find_program_by_name(obj, "classifier_0");
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -296,6 +293,22 @@ out:
|
|||
bpf_object__close(obj);
|
||||
}
|
||||
|
||||
/* test_tailcall_3 checks that the count value of the tail call limit
|
||||
* enforcement matches with expectations. JIT uses direct jump.
|
||||
*/
|
||||
static void test_tailcall_3(void)
|
||||
{
|
||||
test_tailcall_count("tailcall3.o");
|
||||
}
|
||||
|
||||
/* test_tailcall_6 checks that the count value of the tail call limit
|
||||
* enforcement matches with expectations. JIT uses indirect jump.
|
||||
*/
|
||||
static void test_tailcall_6(void)
|
||||
{
|
||||
test_tailcall_count("tailcall6.o");
|
||||
}
|
||||
|
||||
/* test_tailcall_4 checks that the kernel properly selects indirect jump
|
||||
* for the case where the key is not known. Latter is passed via global
|
||||
* data to select different targets we can compare return value of.
|
||||
|
|
@ -316,7 +329,7 @@ static void test_tailcall_4(void)
|
|||
if (CHECK_FAIL(err))
|
||||
return;
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, "classifier");
|
||||
prog = bpf_object__find_program_by_name(obj, "entry");
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -341,9 +354,9 @@ static void test_tailcall_4(void)
|
|||
return;
|
||||
|
||||
for (i = 0; i < bpf_map__def(prog_array)->max_entries; i++) {
|
||||
snprintf(prog_name, sizeof(prog_name), "classifier/%i", i);
|
||||
snprintf(prog_name, sizeof(prog_name), "classifier_%d", i);
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, prog_name);
|
||||
prog = bpf_object__find_program_by_name(obj, prog_name);
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -404,7 +417,7 @@ static void test_tailcall_5(void)
|
|||
if (CHECK_FAIL(err))
|
||||
return;
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, "classifier");
|
||||
prog = bpf_object__find_program_by_name(obj, "entry");
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -429,9 +442,9 @@ static void test_tailcall_5(void)
|
|||
return;
|
||||
|
||||
for (i = 0; i < bpf_map__def(prog_array)->max_entries; i++) {
|
||||
snprintf(prog_name, sizeof(prog_name), "classifier/%i", i);
|
||||
snprintf(prog_name, sizeof(prog_name), "classifier_%d", i);
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, prog_name);
|
||||
prog = bpf_object__find_program_by_name(obj, prog_name);
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -490,7 +503,7 @@ static void test_tailcall_bpf2bpf_1(void)
|
|||
if (CHECK_FAIL(err))
|
||||
return;
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, "classifier");
|
||||
prog = bpf_object__find_program_by_name(obj, "entry");
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -508,9 +521,9 @@ static void test_tailcall_bpf2bpf_1(void)
|
|||
|
||||
/* nop -> jmp */
|
||||
for (i = 0; i < bpf_map__def(prog_array)->max_entries; i++) {
|
||||
snprintf(prog_name, sizeof(prog_name), "classifier/%i", i);
|
||||
snprintf(prog_name, sizeof(prog_name), "classifier_%d", i);
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, prog_name);
|
||||
prog = bpf_object__find_program_by_name(obj, prog_name);
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -574,7 +587,7 @@ static void test_tailcall_bpf2bpf_2(void)
|
|||
if (CHECK_FAIL(err))
|
||||
return;
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, "classifier");
|
||||
prog = bpf_object__find_program_by_name(obj, "entry");
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -590,7 +603,7 @@ static void test_tailcall_bpf2bpf_2(void)
|
|||
if (CHECK_FAIL(map_fd < 0))
|
||||
goto out;
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, "classifier/0");
|
||||
prog = bpf_object__find_program_by_name(obj, "classifier_0");
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -652,7 +665,7 @@ static void test_tailcall_bpf2bpf_3(void)
|
|||
if (CHECK_FAIL(err))
|
||||
return;
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, "classifier");
|
||||
prog = bpf_object__find_program_by_name(obj, "entry");
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -669,9 +682,9 @@ static void test_tailcall_bpf2bpf_3(void)
|
|||
goto out;
|
||||
|
||||
for (i = 0; i < bpf_map__def(prog_array)->max_entries; i++) {
|
||||
snprintf(prog_name, sizeof(prog_name), "classifier/%i", i);
|
||||
snprintf(prog_name, sizeof(prog_name), "classifier_%d", i);
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, prog_name);
|
||||
prog = bpf_object__find_program_by_name(obj, prog_name);
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -749,7 +762,7 @@ static void test_tailcall_bpf2bpf_4(bool noise)
|
|||
if (CHECK_FAIL(err))
|
||||
return;
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, "classifier");
|
||||
prog = bpf_object__find_program_by_name(obj, "entry");
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -766,9 +779,9 @@ static void test_tailcall_bpf2bpf_4(bool noise)
|
|||
goto out;
|
||||
|
||||
for (i = 0; i < bpf_map__def(prog_array)->max_entries; i++) {
|
||||
snprintf(prog_name, sizeof(prog_name), "classifier/%i", i);
|
||||
snprintf(prog_name, sizeof(prog_name), "classifier_%d", i);
|
||||
|
||||
prog = bpf_object__find_program_by_title(obj, prog_name);
|
||||
prog = bpf_object__find_program_by_name(obj, prog_name);
|
||||
if (CHECK_FAIL(!prog))
|
||||
goto out;
|
||||
|
||||
|
|
@ -822,6 +835,8 @@ void test_tailcalls(void)
|
|||
test_tailcall_4();
|
||||
if (test__start_subtest("tailcall_5"))
|
||||
test_tailcall_5();
|
||||
if (test__start_subtest("tailcall_6"))
|
||||
test_tailcall_6();
|
||||
if (test__start_subtest("tailcall_bpf2bpf_1"))
|
||||
test_tailcall_bpf2bpf_1();
|
||||
if (test__start_subtest("tailcall_bpf2bpf_2"))
|
||||
|
|
|
|||
|
|
@ -176,6 +176,18 @@ static int netns_setup_namespaces(const char *verb)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void netns_setup_namespaces_nofail(const char *verb)
|
||||
{
|
||||
const char * const *ns = namespaces;
|
||||
char cmd[128];
|
||||
|
||||
while (*ns) {
|
||||
snprintf(cmd, sizeof(cmd), "ip netns %s %s > /dev/null 2>&1", verb, *ns);
|
||||
system(cmd);
|
||||
ns++;
|
||||
}
|
||||
}
|
||||
|
||||
struct netns_setup_result {
|
||||
int ifindex_veth_src_fwd;
|
||||
int ifindex_veth_dst_fwd;
|
||||
|
|
@ -633,7 +645,7 @@ static void test_tc_redirect_peer_l3(struct netns_setup_result *setup_result)
|
|||
struct nstoken *nstoken = NULL;
|
||||
int err;
|
||||
int tunnel_pid = -1;
|
||||
int src_fd, target_fd;
|
||||
int src_fd, target_fd = -1;
|
||||
int ifindex;
|
||||
|
||||
/* Start a L3 TUN/TAP tunnel between the src and dst namespaces.
|
||||
|
|
@ -762,6 +774,8 @@ fail:
|
|||
|
||||
static void *test_tc_redirect_run_tests(void *arg)
|
||||
{
|
||||
netns_setup_namespaces_nofail("delete");
|
||||
|
||||
RUN_TEST(tc_redirect_peer);
|
||||
RUN_TEST(tc_redirect_peer_l3);
|
||||
RUN_TEST(tc_redirect_neigh);
|
||||
|
|
@ -769,7 +783,7 @@ static void *test_tc_redirect_run_tests(void *arg)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
void test_tc_redirect(void)
|
||||
void serial_test_tc_redirect(void)
|
||||
{
|
||||
pthread_t test_thread;
|
||||
int err;
|
||||
|
|
|
|||
|
|
@ -109,7 +109,7 @@ static int run_test(int cgroup_fd, int server_fd)
|
|||
return -1;
|
||||
}
|
||||
|
||||
map = bpf_map__next(NULL, obj);
|
||||
map = bpf_object__next_map(obj, NULL);
|
||||
map_fd = bpf_map__fd(map);
|
||||
|
||||
err = bpf_prog_attach(prog_fd, cgroup_fd, BPF_CGROUP_SOCK_OPS, 0);
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ static int process_sample(void *ctx, void *data, size_t len)
|
|||
void test_test_ima(void)
|
||||
{
|
||||
char measured_dir_template[] = "/tmp/ima_measuredXXXXXX";
|
||||
struct ring_buffer *ringbuf;
|
||||
struct ring_buffer *ringbuf = NULL;
|
||||
const char *measured_dir;
|
||||
char cmd[256];
|
||||
|
||||
|
|
@ -85,5 +85,6 @@ close_clean:
|
|||
err = system(cmd);
|
||||
CHECK(err, "failed to run command", "%s, errno = %d\n", cmd, errno);
|
||||
close_prog:
|
||||
ring_buffer__free(ringbuf);
|
||||
ima__destroy(skel);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -39,7 +39,8 @@ static int timer(struct timer *timer_skel)
|
|||
return 0;
|
||||
}
|
||||
|
||||
void test_timer(void)
|
||||
/* TODO: use pid filtering */
|
||||
void serial_test_timer(void)
|
||||
{
|
||||
struct timer *timer_skel = NULL;
|
||||
int err;
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ static int timer_mim(struct timer_mim *timer_skel)
|
|||
return 0;
|
||||
}
|
||||
|
||||
void test_timer_mim(void)
|
||||
void serial_test_timer_mim(void)
|
||||
{
|
||||
struct timer_mim_reject *timer_reject_skel = NULL;
|
||||
libbpf_print_fn_t old_print_fn = NULL;
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
#include <test_progs.h>
|
||||
|
||||
void test_tp_attach_query(void)
|
||||
void serial_test_tp_attach_query(void)
|
||||
{
|
||||
const int num_progs = 3;
|
||||
int i, j, bytes, efd, err, prog_fd[num_progs], pmu_fd[num_progs];
|
||||
|
|
|
|||
|
|
@ -8,35 +8,34 @@
|
|||
#define TRACEBUF "/sys/kernel/debug/tracing/trace_pipe"
|
||||
#define SEARCHMSG "testing,testing"
|
||||
|
||||
void test_trace_printk(void)
|
||||
void serial_test_trace_printk(void)
|
||||
{
|
||||
int err, iter = 0, duration = 0, found = 0;
|
||||
struct trace_printk__bss *bss;
|
||||
struct trace_printk *skel;
|
||||
struct trace_printk_lskel__bss *bss;
|
||||
int err = 0, iter = 0, found = 0;
|
||||
struct trace_printk_lskel *skel;
|
||||
char *buf = NULL;
|
||||
FILE *fp = NULL;
|
||||
size_t buflen;
|
||||
|
||||
skel = trace_printk__open();
|
||||
if (CHECK(!skel, "skel_open", "failed to open skeleton\n"))
|
||||
skel = trace_printk_lskel__open();
|
||||
if (!ASSERT_OK_PTR(skel, "trace_printk__open"))
|
||||
return;
|
||||
|
||||
ASSERT_EQ(skel->rodata->fmt[0], 'T', "invalid printk fmt string");
|
||||
ASSERT_EQ(skel->rodata->fmt[0], 'T', "skel->rodata->fmt[0]");
|
||||
skel->rodata->fmt[0] = 't';
|
||||
|
||||
err = trace_printk__load(skel);
|
||||
if (CHECK(err, "skel_load", "failed to load skeleton: %d\n", err))
|
||||
err = trace_printk_lskel__load(skel);
|
||||
if (!ASSERT_OK(err, "trace_printk__load"))
|
||||
goto cleanup;
|
||||
|
||||
bss = skel->bss;
|
||||
|
||||
err = trace_printk__attach(skel);
|
||||
if (CHECK(err, "skel_attach", "skeleton attach failed: %d\n", err))
|
||||
err = trace_printk_lskel__attach(skel);
|
||||
if (!ASSERT_OK(err, "trace_printk__attach"))
|
||||
goto cleanup;
|
||||
|
||||
fp = fopen(TRACEBUF, "r");
|
||||
if (CHECK(fp == NULL, "could not open trace buffer",
|
||||
"error %d opening %s", errno, TRACEBUF))
|
||||
if (!ASSERT_OK_PTR(fp, "fopen(TRACEBUF)"))
|
||||
goto cleanup;
|
||||
|
||||
/* We do not want to wait forever if this test fails... */
|
||||
|
|
@ -44,16 +43,12 @@ void test_trace_printk(void)
|
|||
|
||||
/* wait for tracepoint to trigger */
|
||||
usleep(1);
|
||||
trace_printk__detach(skel);
|
||||
trace_printk_lskel__detach(skel);
|
||||
|
||||
if (CHECK(bss->trace_printk_ran == 0,
|
||||
"bpf_trace_printk never ran",
|
||||
"ran == %d", bss->trace_printk_ran))
|
||||
if (!ASSERT_GT(bss->trace_printk_ran, 0, "bss->trace_printk_ran"))
|
||||
goto cleanup;
|
||||
|
||||
if (CHECK(bss->trace_printk_ret <= 0,
|
||||
"bpf_trace_printk returned <= 0 value",
|
||||
"got %d", bss->trace_printk_ret))
|
||||
if (!ASSERT_GT(bss->trace_printk_ret, 0, "bss->trace_printk_ret"))
|
||||
goto cleanup;
|
||||
|
||||
/* verify our search string is in the trace buffer */
|
||||
|
|
@ -66,12 +61,11 @@ void test_trace_printk(void)
|
|||
break;
|
||||
}
|
||||
|
||||
if (CHECK(!found, "message from bpf_trace_printk not found",
|
||||
"no instance of %s in %s", SEARCHMSG, TRACEBUF))
|
||||
if (!ASSERT_EQ(found, bss->trace_printk_ran, "found"))
|
||||
goto cleanup;
|
||||
|
||||
cleanup:
|
||||
trace_printk__destroy(skel);
|
||||
trace_printk_lskel__destroy(skel);
|
||||
free(buf);
|
||||
if (fp)
|
||||
fclose(fp);
|
||||
|
|
|
|||
68
tools/testing/selftests/bpf/prog_tests/trace_vprintk.c
Normal file
68
tools/testing/selftests/bpf/prog_tests/trace_vprintk.c
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Copyright (c) 2021 Facebook */
|
||||
|
||||
#include <test_progs.h>
|
||||
|
||||
#include "trace_vprintk.lskel.h"
|
||||
|
||||
#define TRACEBUF "/sys/kernel/debug/tracing/trace_pipe"
|
||||
#define SEARCHMSG "1,2,3,4,5,6,7,8,9,10"
|
||||
|
||||
void serial_test_trace_vprintk(void)
|
||||
{
|
||||
struct trace_vprintk_lskel__bss *bss;
|
||||
int err = 0, iter = 0, found = 0;
|
||||
struct trace_vprintk_lskel *skel;
|
||||
char *buf = NULL;
|
||||
FILE *fp = NULL;
|
||||
size_t buflen;
|
||||
|
||||
skel = trace_vprintk_lskel__open_and_load();
|
||||
if (!ASSERT_OK_PTR(skel, "trace_vprintk__open_and_load"))
|
||||
goto cleanup;
|
||||
|
||||
bss = skel->bss;
|
||||
|
||||
err = trace_vprintk_lskel__attach(skel);
|
||||
if (!ASSERT_OK(err, "trace_vprintk__attach"))
|
||||
goto cleanup;
|
||||
|
||||
fp = fopen(TRACEBUF, "r");
|
||||
if (!ASSERT_OK_PTR(fp, "fopen(TRACEBUF)"))
|
||||
goto cleanup;
|
||||
|
||||
/* We do not want to wait forever if this test fails... */
|
||||
fcntl(fileno(fp), F_SETFL, O_NONBLOCK);
|
||||
|
||||
/* wait for tracepoint to trigger */
|
||||
usleep(1);
|
||||
trace_vprintk_lskel__detach(skel);
|
||||
|
||||
if (!ASSERT_GT(bss->trace_vprintk_ran, 0, "bss->trace_vprintk_ran"))
|
||||
goto cleanup;
|
||||
|
||||
if (!ASSERT_GT(bss->trace_vprintk_ret, 0, "bss->trace_vprintk_ret"))
|
||||
goto cleanup;
|
||||
|
||||
/* verify our search string is in the trace buffer */
|
||||
while (getline(&buf, &buflen, fp) >= 0 || errno == EAGAIN) {
|
||||
if (strstr(buf, SEARCHMSG) != NULL)
|
||||
found++;
|
||||
if (found == bss->trace_vprintk_ran)
|
||||
break;
|
||||
if (++iter > 1000)
|
||||
break;
|
||||
}
|
||||
|
||||
if (!ASSERT_EQ(found, bss->trace_vprintk_ran, "found"))
|
||||
goto cleanup;
|
||||
|
||||
if (!ASSERT_LT(bss->null_data_vprintk_ret, 0, "bss->null_data_vprintk_ret"))
|
||||
goto cleanup;
|
||||
|
||||
cleanup:
|
||||
trace_vprintk_lskel__destroy(skel);
|
||||
free(buf);
|
||||
if (fp)
|
||||
fclose(fp);
|
||||
}
|
||||
|
|
@ -41,7 +41,8 @@ static struct bpf_link *load(struct bpf_object *obj, const char *name)
|
|||
return bpf_program__attach_trace(prog);
|
||||
}
|
||||
|
||||
void test_trampoline_count(void)
|
||||
/* TODO: use different target function to run in concurrent mode */
|
||||
void serial_test_trampoline_count(void)
|
||||
{
|
||||
const char *fentry_name = "fentry/__set_task_comm";
|
||||
const char *fexit_name = "fexit/__set_task_comm";
|
||||
|
|
|
|||
28
tools/testing/selftests/bpf/prog_tests/verif_stats.c
Normal file
28
tools/testing/selftests/bpf/prog_tests/verif_stats.c
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* Copyright (c) 2021 Facebook */
|
||||
|
||||
#include <test_progs.h>
|
||||
|
||||
#include "trace_vprintk.lskel.h"
|
||||
|
||||
void test_verif_stats(void)
|
||||
{
|
||||
__u32 len = sizeof(struct bpf_prog_info);
|
||||
struct trace_vprintk_lskel *skel;
|
||||
struct bpf_prog_info info = {};
|
||||
int err;
|
||||
|
||||
skel = trace_vprintk_lskel__open_and_load();
|
||||
if (!ASSERT_OK_PTR(skel, "trace_vprintk__open_and_load"))
|
||||
goto cleanup;
|
||||
|
||||
err = bpf_obj_get_info_by_fd(skel->progs.sys_enter.prog_fd, &info, &len);
|
||||
if (!ASSERT_OK(err, "bpf_obj_get_info_by_fd"))
|
||||
goto cleanup;
|
||||
|
||||
if (!ASSERT_GT(info.verified_insns, 0, "verified_insns"))
|
||||
goto cleanup;
|
||||
|
||||
cleanup:
|
||||
trace_vprintk_lskel__destroy(skel);
|
||||
}
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
#include <test_progs.h>
|
||||
#include <network_helpers.h>
|
||||
|
||||
void test_xdp_adjust_tail_shrink(void)
|
||||
static void test_xdp_adjust_tail_shrink(void)
|
||||
{
|
||||
const char *file = "./test_xdp_adjust_tail_shrink.o";
|
||||
__u32 duration, retval, size, expect_sz;
|
||||
|
|
@ -30,7 +30,7 @@ void test_xdp_adjust_tail_shrink(void)
|
|||
bpf_object__close(obj);
|
||||
}
|
||||
|
||||
void test_xdp_adjust_tail_grow(void)
|
||||
static void test_xdp_adjust_tail_grow(void)
|
||||
{
|
||||
const char *file = "./test_xdp_adjust_tail_grow.o";
|
||||
struct bpf_object *obj;
|
||||
|
|
@ -58,7 +58,7 @@ void test_xdp_adjust_tail_grow(void)
|
|||
bpf_object__close(obj);
|
||||
}
|
||||
|
||||
void test_xdp_adjust_tail_grow2(void)
|
||||
static void test_xdp_adjust_tail_grow2(void)
|
||||
{
|
||||
const char *file = "./test_xdp_adjust_tail_grow.o";
|
||||
char buf[4096]; /* avoid segfault: large buf to hold grow results */
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
#define IFINDEX_LO 1
|
||||
#define XDP_FLAGS_REPLACE (1U << 4)
|
||||
|
||||
void test_xdp_attach(void)
|
||||
void serial_test_xdp_attach(void)
|
||||
{
|
||||
__u32 duration = 0, id1, id2, id0 = 0, len;
|
||||
struct bpf_object *obj1, *obj2, *obj3;
|
||||
|
|
|
|||
|
|
@ -519,7 +519,7 @@ static struct bond_test_case bond_test_cases[] = {
|
|||
{ "xdp_bonding_xor_layer34", BOND_MODE_XOR, BOND_XMIT_POLICY_LAYER34, },
|
||||
};
|
||||
|
||||
void test_xdp_bonding(void)
|
||||
void serial_test_xdp_bonding(void)
|
||||
{
|
||||
libbpf_print_fn_t old_print_fn;
|
||||
struct skeletons skeletons = {};
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
|
||||
#define IFINDEX_LO 1
|
||||
|
||||
void test_xdp_cpumap_attach(void)
|
||||
void serial_test_xdp_cpumap_attach(void)
|
||||
{
|
||||
struct test_xdp_with_cpumap_helpers *skel;
|
||||
struct bpf_prog_info info = {};
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
|
||||
#define IFINDEX_LO 1
|
||||
|
||||
void test_xdp_with_devmap_helpers(void)
|
||||
static void test_xdp_with_devmap_helpers(void)
|
||||
{
|
||||
struct test_xdp_with_devmap_helpers *skel;
|
||||
struct bpf_prog_info info = {};
|
||||
|
|
@ -60,7 +60,7 @@ out_close:
|
|||
test_xdp_with_devmap_helpers__destroy(skel);
|
||||
}
|
||||
|
||||
void test_neg_xdp_devmap_helpers(void)
|
||||
static void test_neg_xdp_devmap_helpers(void)
|
||||
{
|
||||
struct test_xdp_devmap_helpers *skel;
|
||||
|
||||
|
|
@ -72,7 +72,7 @@ void test_neg_xdp_devmap_helpers(void)
|
|||
}
|
||||
|
||||
|
||||
void test_xdp_devmap_attach(void)
|
||||
void serial_test_xdp_devmap_attach(void)
|
||||
{
|
||||
if (test__start_subtest("DEVMAP with programs in entries"))
|
||||
test_xdp_with_devmap_helpers();
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
#define IFINDEX_LO 1
|
||||
|
||||
void test_xdp_info(void)
|
||||
void serial_test_xdp_info(void)
|
||||
{
|
||||
__u32 len = sizeof(struct bpf_prog_info), duration = 0, prog_id;
|
||||
const char *file = "./xdp_dummy.o";
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
#define IFINDEX_LO 1
|
||||
|
||||
void test_xdp_link(void)
|
||||
void serial_test_xdp_link(void)
|
||||
{
|
||||
__u32 duration = 0, id1, id2, id0 = 0, prog_fd1, prog_fd2, err;
|
||||
DECLARE_LIBBPF_OPTS(bpf_xdp_set_link_opts, opts, .old_fd = -1);
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Add a link
Reference in a new issue