tools/testing/selftests/net/psock_tpacket.c

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