1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include <stdio.h>
26#include <stdlib.h>
27#include <sys/types.h>
28#include <sys/stat.h>
29#include <sys/socket.h>
30#include <sys/mman.h>
31#include <linux/if_packet.h>
32#include <linux/filter.h>
33#include <ctype.h>
34#include <fcntl.h>
35#include <unistd.h>
36#include <bits/wordsize.h>
37#include <net/ethernet.h>
38#include <netinet/ip.h>
39#include <arpa/inet.h>
40#include <stdint.h>
41#include <string.h>
42#include <assert.h>
43#include <net/if.h>
44#include <inttypes.h>
45#include <poll.h>
46
47#include "psock_lib.h"
48
49#include "../kselftest.h"
50
51#ifndef bug_on
52# define bug_on(cond) assert(!(cond))
53#endif
54
55#ifndef __aligned_tpacket
56# define __aligned_tpacket __attribute__((aligned(TPACKET_ALIGNMENT)))
57#endif
58
59#ifndef __align_tpacket
60# define __align_tpacket(x) __attribute__((aligned(TPACKET_ALIGN(x))))
61#endif
62
63#define NUM_PACKETS 100
64#define ALIGN_8(x) (((x) + 8 - 1) & ~(8 - 1))
65
66struct ring {
67 struct iovec *rd;
68 uint8_t *mm_space;
69 size_t mm_len, rd_len;
70 struct sockaddr_ll ll;
71 void (*walk)(int sock, struct ring *ring);
72 int type, rd_num, flen, version;
73 union {
74 struct tpacket_req req;
75 struct tpacket_req3 req3;
76 };
77};
78
79struct block_desc {
80 uint32_t version;
81 uint32_t offset_to_priv;
82 struct tpacket_hdr_v1 h1;
83};
84
85union frame_map {
86 struct {
87 struct tpacket_hdr tp_h __aligned_tpacket;
88 struct sockaddr_ll s_ll __align_tpacket(sizeof(struct tpacket_hdr));
89 } *v1;
90 struct {
91 struct tpacket2_hdr tp_h __aligned_tpacket;
92 struct sockaddr_ll s_ll __align_tpacket(sizeof(struct tpacket2_hdr));
93 } *v2;
94 void *raw;
95};
96
97static unsigned int total_packets, total_bytes;
98
99static int pfsocket(int ver)
100{
101 int ret, sock = socket(PF_PACKET, SOCK_RAW, 0);
102 if (sock == -1) {
103 perror("socket");
104 exit(1);
105 }
106
107 ret = setsockopt(sock, SOL_PACKET, PACKET_VERSION, &ver, sizeof(ver));
108 if (ret == -1) {
109 perror("setsockopt");
110 exit(1);
111 }
112
113 return sock;
114}
115
116static void status_bar_update(void)
117{
118 if (total_packets % 10 == 0) {
119 fprintf(stderr, ".");
120 fflush(stderr);
121 }
122}
123
124static void test_payload(void *pay, size_t len)
125{
126 struct ethhdr *eth = pay;
127
128 if (len < sizeof(struct ethhdr)) {
129 fprintf(stderr, "test_payload: packet too "
130 "small: %zu bytes!\n", len);
131 exit(1);
132 }
133
134 if (eth->h_proto != htons(ETH_P_IP)) {
135 fprintf(stderr, "test_payload: wrong ethernet "
136 "type: 0x%x!\n", ntohs(eth->h_proto));
137 exit(1);
138 }
139}
140
141static void create_payload(void *pay, size_t *len)
142{
143 int i;
144 struct ethhdr *eth = pay;
145 struct iphdr *ip = pay + sizeof(*eth);
146
147
148
149
150
151 *len = DATA_LEN + 42;
152
153 memset(pay, 0xff, ETH_ALEN * 2);
154 eth->h_proto = htons(ETH_P_IP);
155
156 for (i = 0; i < sizeof(*ip); ++i)
157 ((uint8_t *) pay)[i + sizeof(*eth)] = (uint8_t) rand();
158
159 ip->ihl = 5;
160 ip->version = 4;
161 ip->protocol = 0x11;
162 ip->frag_off = 0;
163 ip->ttl = 64;
164 ip->tot_len = htons((uint16_t) *len - sizeof(*eth));
165
166 ip->saddr = htonl(INADDR_LOOPBACK);
167 ip->daddr = htonl(INADDR_LOOPBACK);
168
169 memset(pay + sizeof(*eth) + sizeof(*ip),
170 DATA_CHAR, DATA_LEN);
171}
172
173static inline int __v1_rx_kernel_ready(struct tpacket_hdr *hdr)
174{
175 return ((hdr->tp_status & TP_STATUS_USER) == TP_STATUS_USER);
176}
177
178static inline void __v1_rx_user_ready(struct tpacket_hdr *hdr)
179{
180 hdr->tp_status = TP_STATUS_KERNEL;
181 __sync_synchronize();
182}
183
184static inline int __v2_rx_kernel_ready(struct tpacket2_hdr *hdr)
185{
186 return ((hdr->tp_status & TP_STATUS_USER) == TP_STATUS_USER);
187}
188
189static inline void __v2_rx_user_ready(struct tpacket2_hdr *hdr)
190{
191 hdr->tp_status = TP_STATUS_KERNEL;
192 __sync_synchronize();
193}
194
195static inline int __v1_v2_rx_kernel_ready(void *base, int version)
196{
197 switch (version) {
198 case TPACKET_V1:
199 return __v1_rx_kernel_ready(base);
200 case TPACKET_V2:
201 return __v2_rx_kernel_ready(base);
202 default:
203 bug_on(1);
204 return 0;
205 }
206}
207
208static inline void __v1_v2_rx_user_ready(void *base, int version)
209{
210 switch (version) {
211 case TPACKET_V1:
212 __v1_rx_user_ready(base);
213 break;
214 case TPACKET_V2:
215 __v2_rx_user_ready(base);
216 break;
217 }
218}
219
220static void walk_v1_v2_rx(int sock, struct ring *ring)
221{
222 struct pollfd pfd;
223 int udp_sock[2];
224 union frame_map ppd;
225 unsigned int frame_num = 0;
226
227 bug_on(ring->type != PACKET_RX_RING);
228
229 pair_udp_open(udp_sock, PORT_BASE);
230
231 memset(&pfd, 0, sizeof(pfd));
232 pfd.fd = sock;
233 pfd.events = POLLIN | POLLERR;
234 pfd.revents = 0;
235
236 pair_udp_send(udp_sock, NUM_PACKETS);
237
238 while (total_packets < NUM_PACKETS * 2) {
239 while (__v1_v2_rx_kernel_ready(ring->rd[frame_num].iov_base,
240 ring->version)) {
241 ppd.raw = ring->rd[frame_num].iov_base;
242
243 switch (ring->version) {
244 case TPACKET_V1:
245 test_payload((uint8_t *) ppd.raw + ppd.v1->tp_h.tp_mac,
246 ppd.v1->tp_h.tp_snaplen);
247 total_bytes += ppd.v1->tp_h.tp_snaplen;
248 break;
249
250 case TPACKET_V2:
251 test_payload((uint8_t *) ppd.raw + ppd.v2->tp_h.tp_mac,
252 ppd.v2->tp_h.tp_snaplen);
253 total_bytes += ppd.v2->tp_h.tp_snaplen;
254 break;
255 }
256
257 status_bar_update();
258 total_packets++;
259
260 __v1_v2_rx_user_ready(ppd.raw, ring->version);
261
262 frame_num = (frame_num + 1) % ring->rd_num;
263 }
264
265 poll(&pfd, 1, 1);
266 }
267
268 pair_udp_close(udp_sock);
269
270 if (total_packets != 2 * NUM_PACKETS) {
271 fprintf(stderr, "walk_v%d_rx: received %u out of %u pkts\n",
272 ring->version, total_packets, NUM_PACKETS);
273 exit(1);
274 }
275
276 fprintf(stderr, " %u pkts (%u bytes)", NUM_PACKETS, total_bytes >> 1);
277}
278
279static inline int __v1_tx_kernel_ready(struct tpacket_hdr *hdr)
280{
281 return !(hdr->tp_status & (TP_STATUS_SEND_REQUEST | TP_STATUS_SENDING));
282}
283
284static inline void __v1_tx_user_ready(struct tpacket_hdr *hdr)
285{
286 hdr->tp_status = TP_STATUS_SEND_REQUEST;
287 __sync_synchronize();
288}
289
290static inline int __v2_tx_kernel_ready(struct tpacket2_hdr *hdr)
291{
292 return !(hdr->tp_status & (TP_STATUS_SEND_REQUEST | TP_STATUS_SENDING));
293}
294
295static inline void __v2_tx_user_ready(struct tpacket2_hdr *hdr)
296{
297 hdr->tp_status = TP_STATUS_SEND_REQUEST;
298 __sync_synchronize();
299}
300
301static inline int __v3_tx_kernel_ready(struct tpacket3_hdr *hdr)
302{
303 return !(hdr->tp_status & (TP_STATUS_SEND_REQUEST | TP_STATUS_SENDING));
304}
305
306static inline void __v3_tx_user_ready(struct tpacket3_hdr *hdr)
307{
308 hdr->tp_status = TP_STATUS_SEND_REQUEST;
309 __sync_synchronize();
310}
311
312static inline int __tx_kernel_ready(void *base, int version)
313{
314 switch (version) {
315 case TPACKET_V1:
316 return __v1_tx_kernel_ready(base);
317 case TPACKET_V2:
318 return __v2_tx_kernel_ready(base);
319 case TPACKET_V3:
320 return __v3_tx_kernel_ready(base);
321 default:
322 bug_on(1);
323 return 0;
324 }
325}
326
327static inline void __tx_user_ready(void *base, int version)
328{
329 switch (version) {
330 case TPACKET_V1:
331 __v1_tx_user_ready(base);
332 break;
333 case TPACKET_V2:
334 __v2_tx_user_ready(base);
335 break;
336 case TPACKET_V3:
337 __v3_tx_user_ready(base);
338 break;
339 }
340}
341
342static void __v1_v2_set_packet_loss_discard(int sock)
343{
344 int ret, discard = 1;
345
346 ret = setsockopt(sock, SOL_PACKET, PACKET_LOSS, (void *) &discard,
347 sizeof(discard));
348 if (ret == -1) {
349 perror("setsockopt");
350 exit(1);
351 }
352}
353
354static inline void *get_next_frame(struct ring *ring, int n)
355{
356 uint8_t *f0 = ring->rd[0].iov_base;
357
358 switch (ring->version) {
359 case TPACKET_V1:
360 case TPACKET_V2:
361 return ring->rd[n].iov_base;
362 case TPACKET_V3:
363 return f0 + (n * ring->req3.tp_frame_size);
364 default:
365 bug_on(1);
366 }
367}
368
369static void walk_tx(int sock, struct ring *ring)
370{
371 struct pollfd pfd;
372 int rcv_sock, ret;
373 size_t packet_len;
374 union frame_map ppd;
375 char packet[1024];
376 unsigned int frame_num = 0, got = 0;
377 struct sockaddr_ll ll = {
378 .sll_family = PF_PACKET,
379 .sll_halen = ETH_ALEN,
380 };
381 int nframes;
382
383
384
385
386
387 if (ring->version <= TPACKET_V2)
388 nframes = ring->rd_num;
389 else
390 nframes = ring->req3.tp_frame_nr;
391
392 bug_on(ring->type != PACKET_TX_RING);
393 bug_on(nframes < NUM_PACKETS);
394
395 rcv_sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
396 if (rcv_sock == -1) {
397 perror("socket");
398 exit(1);
399 }
400
401 pair_udp_setfilter(rcv_sock);
402
403 ll.sll_ifindex = if_nametoindex("lo");
404 ret = bind(rcv_sock, (struct sockaddr *) &ll, sizeof(ll));
405 if (ret == -1) {
406 perror("bind");
407 exit(1);
408 }
409
410 memset(&pfd, 0, sizeof(pfd));
411 pfd.fd = sock;
412 pfd.events = POLLOUT | POLLERR;
413 pfd.revents = 0;
414
415 total_packets = NUM_PACKETS;
416 create_payload(packet, &packet_len);
417
418 while (total_packets > 0) {
419 void *next = get_next_frame(ring, frame_num);
420
421 while (__tx_kernel_ready(next, ring->version) &&
422 total_packets > 0) {
423 ppd.raw = next;
424
425 switch (ring->version) {
426 case TPACKET_V1:
427 ppd.v1->tp_h.tp_snaplen = packet_len;
428 ppd.v1->tp_h.tp_len = packet_len;
429
430 memcpy((uint8_t *) ppd.raw + TPACKET_HDRLEN -
431 sizeof(struct sockaddr_ll), packet,
432 packet_len);
433 total_bytes += ppd.v1->tp_h.tp_snaplen;
434 break;
435
436 case TPACKET_V2:
437 ppd.v2->tp_h.tp_snaplen = packet_len;
438 ppd.v2->tp_h.tp_len = packet_len;
439
440 memcpy((uint8_t *) ppd.raw + TPACKET2_HDRLEN -
441 sizeof(struct sockaddr_ll), packet,
442 packet_len);
443 total_bytes += ppd.v2->tp_h.tp_snaplen;
444 break;
445 case TPACKET_V3: {
446 struct tpacket3_hdr *tx = next;
447
448 tx->tp_snaplen = packet_len;
449 tx->tp_len = packet_len;
450 tx->tp_next_offset = 0;
451
452 memcpy((uint8_t *)tx + TPACKET3_HDRLEN -
453 sizeof(struct sockaddr_ll), packet,
454 packet_len);
455 total_bytes += tx->tp_snaplen;
456 break;
457 }
458 }
459
460 status_bar_update();
461 total_packets--;
462
463 __tx_user_ready(next, ring->version);
464
465 frame_num = (frame_num + 1) % nframes;
466 }
467
468 poll(&pfd, 1, 1);
469 }
470
471 bug_on(total_packets != 0);
472
473 ret = sendto(sock, NULL, 0, 0, NULL, 0);
474 if (ret == -1) {
475 perror("sendto");
476 exit(1);
477 }
478
479 while ((ret = recvfrom(rcv_sock, packet, sizeof(packet),
480 0, NULL, NULL)) > 0 &&
481 total_packets < NUM_PACKETS) {
482 got += ret;
483 test_payload(packet, ret);
484
485 status_bar_update();
486 total_packets++;
487 }
488
489 close(rcv_sock);
490
491 if (total_packets != NUM_PACKETS) {
492 fprintf(stderr, "walk_v%d_rx: received %u out of %u pkts\n",
493 ring->version, total_packets, NUM_PACKETS);
494 exit(1);
495 }
496
497 fprintf(stderr, " %u pkts (%u bytes)", NUM_PACKETS, got);
498}
499
500static void walk_v1_v2(int sock, struct ring *ring)
501{
502 if (ring->type == PACKET_RX_RING)
503 walk_v1_v2_rx(sock, ring);
504 else
505 walk_tx(sock, ring);
506}
507
508static uint64_t __v3_prev_block_seq_num = 0;
509
510void __v3_test_block_seq_num(struct block_desc *pbd)
511{
512 if (__v3_prev_block_seq_num + 1 != pbd->h1.seq_num) {
513 fprintf(stderr, "\nprev_block_seq_num:%"PRIu64", expected "
514 "seq:%"PRIu64" != actual seq:%"PRIu64"\n",
515 __v3_prev_block_seq_num, __v3_prev_block_seq_num + 1,
516 (uint64_t) pbd->h1.seq_num);
517 exit(1);
518 }
519
520 __v3_prev_block_seq_num = pbd->h1.seq_num;
521}
522
523static void __v3_test_block_len(struct block_desc *pbd, uint32_t bytes, int block_num)
524{
525 if (pbd->h1.num_pkts && bytes != pbd->h1.blk_len) {
526 fprintf(stderr, "\nblock:%u with %upackets, expected "
527 "len:%u != actual len:%u\n", block_num,
528 pbd->h1.num_pkts, bytes, pbd->h1.blk_len);
529 exit(1);
530 }
531}
532
533static void __v3_test_block_header(struct block_desc *pbd, const int block_num)
534{
535 if ((pbd->h1.block_status & TP_STATUS_USER) == 0) {
536 fprintf(stderr, "\nblock %u: not in TP_STATUS_USER\n", block_num);
537 exit(1);
538 }
539
540 __v3_test_block_seq_num(pbd);
541}
542
543static void __v3_walk_block(struct block_desc *pbd, const int block_num)
544{
545 int num_pkts = pbd->h1.num_pkts, i;
546 unsigned long bytes = 0, bytes_with_padding = ALIGN_8(sizeof(*pbd));
547 struct tpacket3_hdr *ppd;
548
549 __v3_test_block_header(pbd, block_num);
550
551 ppd = (struct tpacket3_hdr *) ((uint8_t *) pbd +
552 pbd->h1.offset_to_first_pkt);
553
554 for (i = 0; i < num_pkts; ++i) {
555 bytes += ppd->tp_snaplen;
556
557 if (ppd->tp_next_offset)
558 bytes_with_padding += ppd->tp_next_offset;
559 else
560 bytes_with_padding += ALIGN_8(ppd->tp_snaplen + ppd->tp_mac);
561
562 test_payload((uint8_t *) ppd + ppd->tp_mac, ppd->tp_snaplen);
563
564 status_bar_update();
565 total_packets++;
566
567 ppd = (struct tpacket3_hdr *) ((uint8_t *) ppd + ppd->tp_next_offset);
568 __sync_synchronize();
569 }
570
571 __v3_test_block_len(pbd, bytes_with_padding, block_num);
572 total_bytes += bytes;
573}
574
575void __v3_flush_block(struct block_desc *pbd)
576{
577 pbd->h1.block_status = TP_STATUS_KERNEL;
578 __sync_synchronize();
579}
580
581static void walk_v3_rx(int sock, struct ring *ring)
582{
583 unsigned int block_num = 0;
584 struct pollfd pfd;
585 struct block_desc *pbd;
586 int udp_sock[2];
587
588 bug_on(ring->type != PACKET_RX_RING);
589
590 pair_udp_open(udp_sock, PORT_BASE);
591
592 memset(&pfd, 0, sizeof(pfd));
593 pfd.fd = sock;
594 pfd.events = POLLIN | POLLERR;
595 pfd.revents = 0;
596
597 pair_udp_send(udp_sock, NUM_PACKETS);
598
599 while (total_packets < NUM_PACKETS * 2) {
600 pbd = (struct block_desc *) ring->rd[block_num].iov_base;
601
602 while ((pbd->h1.block_status & TP_STATUS_USER) == 0)
603 poll(&pfd, 1, 1);
604
605 __v3_walk_block(pbd, block_num);
606 __v3_flush_block(pbd);
607
608 block_num = (block_num + 1) % ring->rd_num;
609 }
610
611 pair_udp_close(udp_sock);
612
613 if (total_packets != 2 * NUM_PACKETS) {
614 fprintf(stderr, "walk_v3_rx: received %u out of %u pkts\n",
615 total_packets, NUM_PACKETS);
616 exit(1);
617 }
618
619 fprintf(stderr, " %u pkts (%u bytes)", NUM_PACKETS, total_bytes >> 1);
620}
621
622static void walk_v3(int sock, struct ring *ring)
623{
624 if (ring->type == PACKET_RX_RING)
625 walk_v3_rx(sock, ring);
626 else
627 walk_tx(sock, ring);
628}
629
630static void __v1_v2_fill(struct ring *ring, unsigned int blocks)
631{
632 ring->req.tp_block_size = getpagesize() << 2;
633 ring->req.tp_frame_size = TPACKET_ALIGNMENT << 7;
634 ring->req.tp_block_nr = blocks;
635
636 ring->req.tp_frame_nr = ring->req.tp_block_size /
637 ring->req.tp_frame_size *
638 ring->req.tp_block_nr;
639
640 ring->mm_len = ring->req.tp_block_size * ring->req.tp_block_nr;
641 ring->walk = walk_v1_v2;
642 ring->rd_num = ring->req.tp_frame_nr;
643 ring->flen = ring->req.tp_frame_size;
644}
645
646static void __v3_fill(struct ring *ring, unsigned int blocks, int type)
647{
648 if (type == PACKET_RX_RING) {
649 ring->req3.tp_retire_blk_tov = 64;
650 ring->req3.tp_sizeof_priv = 0;
651 ring->req3.tp_feature_req_word = TP_FT_REQ_FILL_RXHASH;
652 }
653 ring->req3.tp_block_size = getpagesize() << 2;
654 ring->req3.tp_frame_size = TPACKET_ALIGNMENT << 7;
655 ring->req3.tp_block_nr = blocks;
656
657 ring->req3.tp_frame_nr = ring->req3.tp_block_size /
658 ring->req3.tp_frame_size *
659 ring->req3.tp_block_nr;
660
661 ring->mm_len = ring->req3.tp_block_size * ring->req3.tp_block_nr;
662 ring->walk = walk_v3;
663 ring->rd_num = ring->req3.tp_block_nr;
664 ring->flen = ring->req3.tp_block_size;
665}
666
667static void setup_ring(int sock, struct ring *ring, int version, int type)
668{
669 int ret = 0;
670 unsigned int blocks = 256;
671
672 ring->type = type;
673 ring->version = version;
674
675 switch (version) {
676 case TPACKET_V1:
677 case TPACKET_V2:
678 if (type == PACKET_TX_RING)
679 __v1_v2_set_packet_loss_discard(sock);
680 __v1_v2_fill(ring, blocks);
681 ret = setsockopt(sock, SOL_PACKET, type, &ring->req,
682 sizeof(ring->req));
683 break;
684
685 case TPACKET_V3:
686 __v3_fill(ring, blocks, type);
687 ret = setsockopt(sock, SOL_PACKET, type, &ring->req3,
688 sizeof(ring->req3));
689 break;
690 }
691
692 if (ret == -1) {
693 perror("setsockopt");
694 exit(1);
695 }
696
697 ring->rd_len = ring->rd_num * sizeof(*ring->rd);
698 ring->rd = malloc(ring->rd_len);
699 if (ring->rd == NULL) {
700 perror("malloc");
701 exit(1);
702 }
703
704 total_packets = 0;
705 total_bytes = 0;
706}
707
708static void mmap_ring(int sock, struct ring *ring)
709{
710 int i;
711
712 ring->mm_space = mmap(0, ring->mm_len, PROT_READ | PROT_WRITE,
713 MAP_SHARED | MAP_LOCKED | MAP_POPULATE, sock, 0);
714 if (ring->mm_space == MAP_FAILED) {
715 perror("mmap");
716 exit(1);
717 }
718
719 memset(ring->rd, 0, ring->rd_len);
720 for (i = 0; i < ring->rd_num; ++i) {
721 ring->rd[i].iov_base = ring->mm_space + (i * ring->flen);
722 ring->rd[i].iov_len = ring->flen;
723 }
724}
725
726static void bind_ring(int sock, struct ring *ring)
727{
728 int ret;
729
730 pair_udp_setfilter(sock);
731
732 ring->ll.sll_family = PF_PACKET;
733 ring->ll.sll_protocol = htons(ETH_P_ALL);
734 ring->ll.sll_ifindex = if_nametoindex("lo");
735 ring->ll.sll_hatype = 0;
736 ring->ll.sll_pkttype = 0;
737 ring->ll.sll_halen = 0;
738
739 ret = bind(sock, (struct sockaddr *) &ring->ll, sizeof(ring->ll));
740 if (ret == -1) {
741 perror("bind");
742 exit(1);
743 }
744}
745
746static void walk_ring(int sock, struct ring *ring)
747{
748 ring->walk(sock, ring);
749}
750
751static void unmap_ring(int sock, struct ring *ring)
752{
753 munmap(ring->mm_space, ring->mm_len);
754 free(ring->rd);
755}
756
757static int test_kernel_bit_width(void)
758{
759 char in[512], *ptr;
760 int num = 0, fd;
761 ssize_t ret;
762
763 fd = open("/proc/kallsyms", O_RDONLY);
764 if (fd == -1) {
765 perror("open");
766 exit(1);
767 }
768
769 ret = read(fd, in, sizeof(in));
770 if (ret <= 0) {
771 perror("read");
772 exit(1);
773 }
774
775 close(fd);
776
777 ptr = in;
778 while(!isspace(*ptr)) {
779 num++;
780 ptr++;
781 }
782
783 return num * 4;
784}
785
786static int test_user_bit_width(void)
787{
788 return __WORDSIZE;
789}
790
791static const char *tpacket_str[] = {
792 [TPACKET_V1] = "TPACKET_V1",
793 [TPACKET_V2] = "TPACKET_V2",
794 [TPACKET_V3] = "TPACKET_V3",
795};
796
797static const char *type_str[] = {
798 [PACKET_RX_RING] = "PACKET_RX_RING",
799 [PACKET_TX_RING] = "PACKET_TX_RING",
800};
801
802static int test_tpacket(int version, int type)
803{
804 int sock;
805 struct ring ring;
806
807 fprintf(stderr, "test: %s with %s ", tpacket_str[version],
808 type_str[type]);
809 fflush(stderr);
810
811 if (version == TPACKET_V1 &&
812 test_kernel_bit_width() != test_user_bit_width()) {
813 fprintf(stderr, "test: skip %s %s since user and kernel "
814 "space have different bit width\n",
815 tpacket_str[version], type_str[type]);
816 return KSFT_SKIP;
817 }
818
819 sock = pfsocket(version);
820 memset(&ring, 0, sizeof(ring));
821 setup_ring(sock, &ring, version, type);
822 mmap_ring(sock, &ring);
823 bind_ring(sock, &ring);
824 walk_ring(sock, &ring);
825 unmap_ring(sock, &ring);
826 close(sock);
827
828 fprintf(stderr, "\n");
829 return 0;
830}
831
832int main(void)
833{
834 int ret = 0;
835
836 ret |= test_tpacket(TPACKET_V1, PACKET_RX_RING);
837 ret |= test_tpacket(TPACKET_V1, PACKET_TX_RING);
838
839 ret |= test_tpacket(TPACKET_V2, PACKET_RX_RING);
840 ret |= test_tpacket(TPACKET_V2, PACKET_TX_RING);
841
842 ret |= test_tpacket(TPACKET_V3, PACKET_RX_RING);
843 ret |= test_tpacket(TPACKET_V3, PACKET_TX_RING);
844
845 if (ret)
846 return 1;
847
848 printf("OK. All tests passed\n");
849 return 0;
850}
851
