2 * Copyright 2013 Google Inc.
3 * Author: Willem de Bruijn (willemb@google.com)
5 * A basic test of packet socket fanout behavior.
8 * - create fanout fails as expected with illegal flag combinations
9 * - join fanout fails as expected with diverging types or flags
12 * Open a pair of packet sockets and a pair of INET sockets, send a known
13 * number of packets across the two INET sockets and count the number of
14 * packets enqueued onto the two packet sockets.
16 * The test currently runs for
17 * - PACKET_FANOUT_HASH
18 * - PACKET_FANOUT_HASH with PACKET_FANOUT_FLAG_ROLLOVER
21 * - PACKET_FANOUT_ROLLOVER
22 * - PACKET_FANOUT_CBPF
23 * - PACKET_FANOUT_EBPF
26 * - functionality: PACKET_FANOUT_FLAG_DEFRAG
30 * This program is free software; you can redistribute it and/or modify it
31 * under the terms and conditions of the GNU General Public License,
32 * version 2, as published by the Free Software Foundation.
34 * This program is distributed in the hope it will be useful, but WITHOUT
35 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
36 * FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for
39 * You should have received a copy of the GNU General Public License along with
40 * this program; if not, write to the Free Software Foundation, Inc.,
41 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
44 #define _GNU_SOURCE /* for sched_setaffinity */
46 #include <arpa/inet.h>
49 #include <linux/unistd.h> /* for __NR_bpf */
50 #include <linux/filter.h>
51 #include <linux/bpf.h>
52 #include <linux/if_packet.h>
53 #include <net/ethernet.h>
54 #include <netinet/ip.h>
55 #include <netinet/udp.h>
63 #include <sys/socket.h>
65 #include <sys/types.h>
68 #include "psock_lib.h"
70 #define RING_NUM_FRAMES 20
72 /* Open a socket in a given fanout mode.
73 * @return -1 if mode is bad, a valid socket otherwise */
74 static int sock_fanout_open(uint16_t typeflags
, int num_packets
)
78 fd
= socket(PF_PACKET
, SOCK_RAW
, htons(ETH_P_IP
));
80 perror("socket packet");
84 /* fanout group ID is always 0: tests whether old groups are deleted */
85 val
= ((int) typeflags
) << 16;
86 if (setsockopt(fd
, SOL_PACKET
, PACKET_FANOUT
, &val
, sizeof(val
))) {
88 perror("close packet");
94 pair_udp_setfilter(fd
);
98 static void sock_fanout_set_cbpf(int fd
)
100 struct sock_filter bpf_filter
[] = {
101 BPF_STMT(BPF_LD
+BPF_B
+BPF_ABS
, 80), /* ldb [80] */
102 BPF_STMT(BPF_RET
+BPF_A
, 0), /* ret A */
104 struct sock_fprog bpf_prog
;
106 bpf_prog
.filter
= bpf_filter
;
107 bpf_prog
.len
= sizeof(bpf_filter
) / sizeof(struct sock_filter
);
109 if (setsockopt(fd
, SOL_PACKET
, PACKET_FANOUT_DATA
, &bpf_prog
,
111 perror("fanout data cbpf");
116 static void sock_fanout_set_ebpf(int fd
)
118 const int len_off
= __builtin_offsetof(struct __sk_buff
, len
);
119 struct bpf_insn prog
[] = {
120 { BPF_ALU64
| BPF_MOV
| BPF_X
, 6, 1, 0, 0 },
121 { BPF_LDX
| BPF_W
| BPF_MEM
, 0, 6, len_off
, 0 },
122 { BPF_JMP
| BPF_JGE
| BPF_K
, 0, 0, 1, DATA_LEN
},
123 { BPF_JMP
| BPF_JA
| BPF_K
, 0, 0, 4, 0 },
124 { BPF_LD
| BPF_B
| BPF_ABS
, 0, 0, 0, 0x50 },
125 { BPF_JMP
| BPF_JEQ
| BPF_K
, 0, 0, 2, DATA_CHAR
},
126 { BPF_JMP
| BPF_JEQ
| BPF_K
, 0, 0, 1, DATA_CHAR_1
},
127 { BPF_ALU
| BPF_MOV
| BPF_K
, 0, 0, 0, 0 },
128 { BPF_JMP
| BPF_EXIT
, 0, 0, 0, 0 }
134 memset(&attr
, 0, sizeof(attr
));
135 attr
.prog_type
= BPF_PROG_TYPE_SOCKET_FILTER
;
136 attr
.insns
= (unsigned long) prog
;
137 attr
.insn_cnt
= sizeof(prog
) / sizeof(prog
[0]);
138 attr
.license
= (unsigned long) "GPL";
139 attr
.log_buf
= (unsigned long) log_buf
,
140 attr
.log_size
= sizeof(log_buf
),
143 pfd
= syscall(__NR_bpf
, BPF_PROG_LOAD
, &attr
, sizeof(attr
));
146 fprintf(stderr
, "bpf verifier:\n%s\n", log_buf
);
150 if (setsockopt(fd
, SOL_PACKET
, PACKET_FANOUT_DATA
, &pfd
, sizeof(pfd
))) {
151 perror("fanout data ebpf");
156 perror("close ebpf");
161 static char *sock_fanout_open_ring(int fd
)
163 struct tpacket_req req
= {
164 .tp_block_size
= getpagesize(),
165 .tp_frame_size
= getpagesize(),
166 .tp_block_nr
= RING_NUM_FRAMES
,
167 .tp_frame_nr
= RING_NUM_FRAMES
,
170 int val
= TPACKET_V2
;
172 if (setsockopt(fd
, SOL_PACKET
, PACKET_VERSION
, (void *) &val
,
174 perror("packetsock ring setsockopt version");
177 if (setsockopt(fd
, SOL_PACKET
, PACKET_RX_RING
, (void *) &req
,
179 perror("packetsock ring setsockopt");
183 ring
= mmap(0, req
.tp_block_size
* req
.tp_block_nr
,
184 PROT_READ
| PROT_WRITE
, MAP_SHARED
, fd
, 0);
185 if (ring
== MAP_FAILED
) {
186 perror("packetsock ring mmap");
193 static int sock_fanout_read_ring(int fd
, void *ring
)
195 struct tpacket2_hdr
*header
= ring
;
198 while (count
< RING_NUM_FRAMES
&& header
->tp_status
& TP_STATUS_USER
) {
200 header
= ring
+ (count
* getpagesize());
206 static int sock_fanout_read(int fds
[], char *rings
[], const int expect
[])
210 ret
[0] = sock_fanout_read_ring(fds
[0], rings
[0]);
211 ret
[1] = sock_fanout_read_ring(fds
[1], rings
[1]);
213 fprintf(stderr
, "info: count=%d,%d, expect=%d,%d\n",
214 ret
[0], ret
[1], expect
[0], expect
[1]);
216 if ((!(ret
[0] == expect
[0] && ret
[1] == expect
[1])) &&
217 (!(ret
[0] == expect
[1] && ret
[1] == expect
[0]))) {
218 fprintf(stderr
, "ERROR: incorrect queue lengths\n");
225 /* Test illegal mode + flag combination */
226 static void test_control_single(void)
228 fprintf(stderr
, "test: control single socket\n");
230 if (sock_fanout_open(PACKET_FANOUT_ROLLOVER
|
231 PACKET_FANOUT_FLAG_ROLLOVER
, 0) != -1) {
232 fprintf(stderr
, "ERROR: opened socket with dual rollover\n");
237 /* Test illegal group with different modes or flags */
238 static void test_control_group(void)
242 fprintf(stderr
, "test: control multiple sockets\n");
244 fds
[0] = sock_fanout_open(PACKET_FANOUT_HASH
, 20);
246 fprintf(stderr
, "ERROR: failed to open HASH socket\n");
249 if (sock_fanout_open(PACKET_FANOUT_HASH
|
250 PACKET_FANOUT_FLAG_DEFRAG
, 10) != -1) {
251 fprintf(stderr
, "ERROR: joined group with wrong flag defrag\n");
254 if (sock_fanout_open(PACKET_FANOUT_HASH
|
255 PACKET_FANOUT_FLAG_ROLLOVER
, 10) != -1) {
256 fprintf(stderr
, "ERROR: joined group with wrong flag ro\n");
259 if (sock_fanout_open(PACKET_FANOUT_CPU
, 10) != -1) {
260 fprintf(stderr
, "ERROR: joined group with wrong mode\n");
263 fds
[1] = sock_fanout_open(PACKET_FANOUT_HASH
, 20);
265 fprintf(stderr
, "ERROR: failed to join group\n");
268 if (close(fds
[1]) || close(fds
[0])) {
269 fprintf(stderr
, "ERROR: closing sockets\n");
274 static int test_datapath(uint16_t typeflags
, int port_off
,
275 const int expect1
[], const int expect2
[])
277 const int expect0
[] = { 0, 0 };
279 uint8_t type
= typeflags
& 0xFF;
280 int fds
[2], fds_udp
[2][2], ret
;
282 fprintf(stderr
, "test: datapath 0x%hx\n", typeflags
);
284 fds
[0] = sock_fanout_open(typeflags
, 20);
285 fds
[1] = sock_fanout_open(typeflags
, 20);
286 if (fds
[0] == -1 || fds
[1] == -1) {
287 fprintf(stderr
, "ERROR: failed open\n");
290 if (type
== PACKET_FANOUT_CBPF
)
291 sock_fanout_set_cbpf(fds
[0]);
292 else if (type
== PACKET_FANOUT_EBPF
)
293 sock_fanout_set_ebpf(fds
[0]);
295 rings
[0] = sock_fanout_open_ring(fds
[0]);
296 rings
[1] = sock_fanout_open_ring(fds
[1]);
297 pair_udp_open(fds_udp
[0], PORT_BASE
);
298 pair_udp_open(fds_udp
[1], PORT_BASE
+ port_off
);
299 sock_fanout_read(fds
, rings
, expect0
);
301 /* Send data, but not enough to overflow a queue */
302 pair_udp_send(fds_udp
[0], 15);
303 pair_udp_send_char(fds_udp
[1], 5, DATA_CHAR_1
);
304 ret
= sock_fanout_read(fds
, rings
, expect1
);
306 /* Send more data, overflow the queue */
307 pair_udp_send_char(fds_udp
[0], 15, DATA_CHAR_1
);
308 /* TODO: ensure consistent order between expect1 and expect2 */
309 ret
|= sock_fanout_read(fds
, rings
, expect2
);
311 if (munmap(rings
[1], RING_NUM_FRAMES
* getpagesize()) ||
312 munmap(rings
[0], RING_NUM_FRAMES
* getpagesize())) {
313 fprintf(stderr
, "close rings\n");
316 if (close(fds_udp
[1][1]) || close(fds_udp
[1][0]) ||
317 close(fds_udp
[0][1]) || close(fds_udp
[0][0]) ||
318 close(fds
[1]) || close(fds
[0])) {
319 fprintf(stderr
, "close datapath\n");
326 static int set_cpuaffinity(int cpuid
)
331 CPU_SET(cpuid
, &mask
);
332 if (sched_setaffinity(0, sizeof(mask
), &mask
)) {
333 if (errno
!= EINVAL
) {
334 fprintf(stderr
, "setaffinity %d\n", cpuid
);
343 int main(int argc
, char **argv
)
345 const int expect_hash
[2][2] = { { 15, 5 }, { 20, 5 } };
346 const int expect_hash_rb
[2][2] = { { 15, 5 }, { 20, 15 } };
347 const int expect_lb
[2][2] = { { 10, 10 }, { 18, 17 } };
348 const int expect_rb
[2][2] = { { 15, 5 }, { 20, 15 } };
349 const int expect_cpu0
[2][2] = { { 20, 0 }, { 20, 0 } };
350 const int expect_cpu1
[2][2] = { { 0, 20 }, { 0, 20 } };
351 const int expect_bpf
[2][2] = { { 15, 5 }, { 15, 20 } };
352 int port_off
= 2, tries
= 5, ret
;
354 test_control_single();
355 test_control_group();
357 /* find a set of ports that do not collide onto the same socket */
358 ret
= test_datapath(PACKET_FANOUT_HASH
, port_off
,
359 expect_hash
[0], expect_hash
[1]);
360 while (ret
&& tries
--) {
361 fprintf(stderr
, "info: trying alternate ports (%d)\n", tries
);
362 ret
= test_datapath(PACKET_FANOUT_HASH
, ++port_off
,
363 expect_hash
[0], expect_hash
[1]);
366 ret
|= test_datapath(PACKET_FANOUT_HASH
| PACKET_FANOUT_FLAG_ROLLOVER
,
367 port_off
, expect_hash_rb
[0], expect_hash_rb
[1]);
368 ret
|= test_datapath(PACKET_FANOUT_LB
,
369 port_off
, expect_lb
[0], expect_lb
[1]);
370 ret
|= test_datapath(PACKET_FANOUT_ROLLOVER
,
371 port_off
, expect_rb
[0], expect_rb
[1]);
373 ret
|= test_datapath(PACKET_FANOUT_CBPF
,
374 port_off
, expect_bpf
[0], expect_bpf
[1]);
375 ret
|= test_datapath(PACKET_FANOUT_EBPF
,
376 port_off
, expect_bpf
[0], expect_bpf
[1]);
379 ret
|= test_datapath(PACKET_FANOUT_CPU
, port_off
,
380 expect_cpu0
[0], expect_cpu0
[1]);
381 if (!set_cpuaffinity(1))
382 /* TODO: test that choice alternates with previous */
383 ret
|= test_datapath(PACKET_FANOUT_CPU
, port_off
,
384 expect_cpu1
[0], expect_cpu1
[1]);
389 printf("OK. All tests passed\n");