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