tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0
2#include <stdio.h>
3#include <stdlib.h>
4#include <string.h>
5#include <errno.h>
6#include <assert.h>
7#include <sys/sysinfo.h>
8#include <sys/time.h>
9
10#include <linux/bpf.h>
11#include <bpf/bpf.h>
12#include <bpf/libbpf.h>
13
14#include "cgroup_helpers.h"
15#include "bpf_rlimit.h"
16#include "netcnt_common.h"
17
18#define BPF_PROG "./netcnt_prog.o"
19#define TEST_CGROUP "/test-network-counters/"
20
21static int bpf_find_map(const char *test, struct bpf_object *obj,
22 const char *name)
23{
24 struct bpf_map *map;
25
26 map = bpf_object__find_map_by_name(obj, name);
27 if (!map) {
28 printf("%s:FAIL:map '%s' not found\n", test, name);
29 return -1;
30 }
31 return bpf_map__fd(map);
32}
33
34int main(int argc, char **argv)
35{
36 struct percpu_net_cnt *percpu_netcnt;
37 struct bpf_cgroup_storage_key key;
38 int map_fd, percpu_map_fd;
39 int error = EXIT_FAILURE;
40 struct net_cnt netcnt;
41 struct bpf_object *obj;
42 int prog_fd, cgroup_fd;
43 unsigned long packets;
44 unsigned long bytes;
45 int cpu, nproc;
46 __u32 prog_cnt;
47
48 nproc = get_nprocs_conf();
49 percpu_netcnt = malloc(sizeof(*percpu_netcnt) * nproc);
50 if (!percpu_netcnt) {
51 printf("Not enough memory for per-cpu area (%d cpus)\n", nproc);
52 goto err;
53 }
54
55 if (bpf_prog_load(BPF_PROG, BPF_PROG_TYPE_CGROUP_SKB,
56 &obj, &prog_fd)) {
57 printf("Failed to load bpf program\n");
58 goto out;
59 }
60
61 if (setup_cgroup_environment()) {
62 printf("Failed to load bpf program\n");
63 goto err;
64 }
65
66 /* Create a cgroup, get fd, and join it */
67 cgroup_fd = create_and_get_cgroup(TEST_CGROUP);
68 if (!cgroup_fd) {
69 printf("Failed to create test cgroup\n");
70 goto err;
71 }
72
73 if (join_cgroup(TEST_CGROUP)) {
74 printf("Failed to join cgroup\n");
75 goto err;
76 }
77
78 /* Attach bpf program */
79 if (bpf_prog_attach(prog_fd, cgroup_fd, BPF_CGROUP_INET_EGRESS, 0)) {
80 printf("Failed to attach bpf program");
81 goto err;
82 }
83
84 assert(system("ping localhost -6 -c 10000 -f -q > /dev/null") == 0);
85
86 if (bpf_prog_query(cgroup_fd, BPF_CGROUP_INET_EGRESS, 0, NULL, NULL,
87 &prog_cnt)) {
88 printf("Failed to query attached programs");
89 goto err;
90 }
91
92 map_fd = bpf_find_map(__func__, obj, "netcnt");
93 if (map_fd < 0) {
94 printf("Failed to find bpf map with net counters");
95 goto err;
96 }
97
98 percpu_map_fd = bpf_find_map(__func__, obj, "percpu_netcnt");
99 if (percpu_map_fd < 0) {
100 printf("Failed to find bpf map with percpu net counters");
101 goto err;
102 }
103
104 if (bpf_map_get_next_key(map_fd, NULL, &key)) {
105 printf("Failed to get key in cgroup storage\n");
106 goto err;
107 }
108
109 if (bpf_map_lookup_elem(map_fd, &key, &netcnt)) {
110 printf("Failed to lookup cgroup storage\n");
111 goto err;
112 }
113
114 if (bpf_map_lookup_elem(percpu_map_fd, &key, &percpu_netcnt[0])) {
115 printf("Failed to lookup percpu cgroup storage\n");
116 goto err;
117 }
118
119 /* Some packets can be still in per-cpu cache, but not more than
120 * MAX_PERCPU_PACKETS.
121 */
122 packets = netcnt.packets;
123 bytes = netcnt.bytes;
124 for (cpu = 0; cpu < nproc; cpu++) {
125 if (percpu_netcnt[cpu].packets > MAX_PERCPU_PACKETS) {
126 printf("Unexpected percpu value: %llu\n",
127 percpu_netcnt[cpu].packets);
128 goto err;
129 }
130
131 packets += percpu_netcnt[cpu].packets;
132 bytes += percpu_netcnt[cpu].bytes;
133 }
134
135 /* No packets should be lost */
136 if (packets != 10000) {
137 printf("Unexpected packet count: %lu\n", packets);
138 goto err;
139 }
140
141 /* Let's check that bytes counter matches the number of packets
142 * multiplied by the size of ipv6 ICMP packet.
143 */
144 if (bytes != packets * 104) {
145 printf("Unexpected bytes count: %lu\n", bytes);
146 goto err;
147 }
148
149 error = 0;
150 printf("test_netcnt:PASS\n");
151
152err:
153 cleanup_cgroup_environment();
154 free(percpu_netcnt);
155
156out:
157 return error;
158}