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