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 __v3_tx_kernel_ready(struct tpacket3_hdr *hdr) 315 { 316 return !(hdr->tp_status & (TP_STATUS_SEND_REQUEST | TP_STATUS_SENDING)); 317 } 318 319 static inline void __v3_tx_user_ready(struct tpacket3_hdr *hdr) 320 { 321 hdr->tp_status = TP_STATUS_SEND_REQUEST; 322 __sync_synchronize(); 323 } 324 325 static inline int __tx_kernel_ready(void *base, int version) 326 { 327 switch (version) { 328 case TPACKET_V1: 329 return __v1_tx_kernel_ready(base); 330 case TPACKET_V2: 331 return __v2_tx_kernel_ready(base); 332 case TPACKET_V3: 333 return __v3_tx_kernel_ready(base); 334 default: 335 bug_on(1); 336 return 0; 337 } 338 } 339 340 static inline void __tx_user_ready(void *base, int version) 341 { 342 switch (version) { 343 case TPACKET_V1: 344 __v1_tx_user_ready(base); 345 break; 346 case TPACKET_V2: 347 __v2_tx_user_ready(base); 348 break; 349 case TPACKET_V3: 350 __v3_tx_user_ready(base); 351 break; 352 } 353 } 354 355 static void __v1_v2_set_packet_loss_discard(int sock) 356 { 357 int ret, discard = 1; 358 359 ret = setsockopt(sock, SOL_PACKET, PACKET_LOSS, (void *) &discard, 360 sizeof(discard)); 361 if (ret == -1) { 362 perror("setsockopt"); 363 exit(1); 364 } 365 } 366 367 static inline void *get_next_frame(struct ring *ring, int n) 368 { 369 uint8_t *f0 = ring->rd[0].iov_base; 370 371 switch (ring->version) { 372 case TPACKET_V1: 373 case TPACKET_V2: 374 return ring->rd[n].iov_base; 375 case TPACKET_V3: 376 return f0 + (n * ring->req3.tp_frame_size); 377 default: 378 bug_on(1); 379 } 380 } 381 382 static void walk_tx(int sock, struct ring *ring) 383 { 384 struct pollfd pfd; 385 int rcv_sock, ret; 386 size_t packet_len; 387 union frame_map ppd; 388 char packet[1024]; 389 unsigned int frame_num = 0, got = 0; 390 struct sockaddr_ll ll = { 391 .sll_family = PF_PACKET, 392 .sll_halen = ETH_ALEN, 393 }; 394 int nframes; 395 396 /* TPACKET_V{1,2} sets up the ring->rd* related variables based 397 * on frames (e.g., rd_num is tp_frame_nr) whereas V3 sets these 398 * up based on blocks (e.g, rd_num is tp_block_nr) 399 */ 400 if (ring->version <= TPACKET_V2) 401 nframes = ring->rd_num; 402 else 403 nframes = ring->req3.tp_frame_nr; 404 405 bug_on(ring->type != PACKET_TX_RING); 406 bug_on(nframes < NUM_PACKETS); 407 408 rcv_sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL)); 409 if (rcv_sock == -1) { 410 perror("socket"); 411 exit(1); 412 } 413 414 pair_udp_setfilter(rcv_sock); 415 416 ll.sll_ifindex = if_nametoindex("lo"); 417 ret = bind(rcv_sock, (struct sockaddr *) &ll, sizeof(ll)); 418 if (ret == -1) { 419 perror("bind"); 420 exit(1); 421 } 422 423 memset(&pfd, 0, sizeof(pfd)); 424 pfd.fd = sock; 425 pfd.events = POLLOUT | POLLERR; 426 pfd.revents = 0; 427 428 total_packets = NUM_PACKETS; 429 create_payload(packet, &packet_len); 430 431 while (total_packets > 0) { 432 void *next = get_next_frame(ring, frame_num); 433 434 while (__tx_kernel_ready(next, ring->version) && 435 total_packets > 0) { 436 ppd.raw = next; 437 438 switch (ring->version) { 439 case TPACKET_V1: 440 ppd.v1->tp_h.tp_snaplen = packet_len; 441 ppd.v1->tp_h.tp_len = packet_len; 442 443 memcpy((uint8_t *) ppd.raw + TPACKET_HDRLEN - 444 sizeof(struct sockaddr_ll), packet, 445 packet_len); 446 total_bytes += ppd.v1->tp_h.tp_snaplen; 447 break; 448 449 case TPACKET_V2: 450 ppd.v2->tp_h.tp_snaplen = packet_len; 451 ppd.v2->tp_h.tp_len = packet_len; 452 453 memcpy((uint8_t *) ppd.raw + TPACKET2_HDRLEN - 454 sizeof(struct sockaddr_ll), packet, 455 packet_len); 456 total_bytes += ppd.v2->tp_h.tp_snaplen; 457 break; 458 case TPACKET_V3: { 459 struct tpacket3_hdr *tx = next; 460 461 tx->tp_snaplen = packet_len; 462 tx->tp_len = packet_len; 463 tx->tp_next_offset = 0; 464 465 memcpy((uint8_t *)tx + TPACKET3_HDRLEN - 466 sizeof(struct sockaddr_ll), packet, 467 packet_len); 468 total_bytes += tx->tp_snaplen; 469 break; 470 } 471 } 472 473 status_bar_update(); 474 total_packets--; 475 476 __tx_user_ready(next, ring->version); 477 478 frame_num = (frame_num + 1) % nframes; 479 } 480 481 poll(&pfd, 1, 1); 482 } 483 484 bug_on(total_packets != 0); 485 486 ret = sendto(sock, NULL, 0, 0, NULL, 0); 487 if (ret == -1) { 488 perror("sendto"); 489 exit(1); 490 } 491 492 while ((ret = recvfrom(rcv_sock, packet, sizeof(packet), 493 0, NULL, NULL)) > 0 && 494 total_packets < NUM_PACKETS) { 495 got += ret; 496 test_payload(packet, ret); 497 498 status_bar_update(); 499 total_packets++; 500 } 501 502 close(rcv_sock); 503 504 if (total_packets != NUM_PACKETS) { 505 fprintf(stderr, "walk_v%d_rx: received %u out of %u pkts\n", 506 ring->version, total_packets, NUM_PACKETS); 507 exit(1); 508 } 509 510 fprintf(stderr, " %u pkts (%u bytes)", NUM_PACKETS, got); 511 } 512 513 static void walk_v1_v2(int sock, struct ring *ring) 514 { 515 if (ring->type == PACKET_RX_RING) 516 walk_v1_v2_rx(sock, ring); 517 else 518 walk_tx(sock, ring); 519 } 520 521 static uint64_t __v3_prev_block_seq_num = 0; 522 523 void __v3_test_block_seq_num(struct block_desc *pbd) 524 { 525 if (__v3_prev_block_seq_num + 1 != pbd->h1.seq_num) { 526 fprintf(stderr, "\nprev_block_seq_num:%"PRIu64", expected " 527 "seq:%"PRIu64" != actual seq:%"PRIu64"\n", 528 __v3_prev_block_seq_num, __v3_prev_block_seq_num + 1, 529 (uint64_t) pbd->h1.seq_num); 530 exit(1); 531 } 532 533 __v3_prev_block_seq_num = pbd->h1.seq_num; 534 } 535 536 static void __v3_test_block_len(struct block_desc *pbd, uint32_t bytes, int block_num) 537 { 538 if (pbd->h1.num_pkts && bytes != pbd->h1.blk_len) { 539 fprintf(stderr, "\nblock:%u with %upackets, expected " 540 "len:%u != actual len:%u\n", block_num, 541 pbd->h1.num_pkts, bytes, pbd->h1.blk_len); 542 exit(1); 543 } 544 } 545 546 static void __v3_test_block_header(struct block_desc *pbd, const int block_num) 547 { 548 if ((pbd->h1.block_status & TP_STATUS_USER) == 0) { 549 fprintf(stderr, "\nblock %u: not in TP_STATUS_USER\n", block_num); 550 exit(1); 551 } 552 553 __v3_test_block_seq_num(pbd); 554 } 555 556 static void __v3_walk_block(struct block_desc *pbd, const int block_num) 557 { 558 int num_pkts = pbd->h1.num_pkts, i; 559 unsigned long bytes = 0, bytes_with_padding = ALIGN_8(sizeof(*pbd)); 560 struct tpacket3_hdr *ppd; 561 562 __v3_test_block_header(pbd, block_num); 563 564 ppd = (struct tpacket3_hdr *) ((uint8_t *) pbd + 565 pbd->h1.offset_to_first_pkt); 566 567 for (i = 0; i < num_pkts; ++i) { 568 bytes += ppd->tp_snaplen; 569 570 if (ppd->tp_next_offset) 571 bytes_with_padding += ppd->tp_next_offset; 572 else 573 bytes_with_padding += ALIGN_8(ppd->tp_snaplen + ppd->tp_mac); 574 575 test_payload((uint8_t *) ppd + ppd->tp_mac, ppd->tp_snaplen); 576 577 status_bar_update(); 578 total_packets++; 579 580 ppd = (struct tpacket3_hdr *) ((uint8_t *) ppd + ppd->tp_next_offset); 581 __sync_synchronize(); 582 } 583 584 __v3_test_block_len(pbd, bytes_with_padding, block_num); 585 total_bytes += bytes; 586 } 587 588 void __v3_flush_block(struct block_desc *pbd) 589 { 590 pbd->h1.block_status = TP_STATUS_KERNEL; 591 __sync_synchronize(); 592 } 593 594 static void walk_v3_rx(int sock, struct ring *ring) 595 { 596 unsigned int block_num = 0; 597 struct pollfd pfd; 598 struct block_desc *pbd; 599 int udp_sock[2]; 600 601 bug_on(ring->type != PACKET_RX_RING); 602 603 pair_udp_open(udp_sock, PORT_BASE); 604 pair_udp_setfilter(sock); 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 ring->ll.sll_family = PF_PACKET; 745 ring->ll.sll_protocol = htons(ETH_P_ALL); 746 ring->ll.sll_ifindex = if_nametoindex("lo"); 747 ring->ll.sll_hatype = 0; 748 ring->ll.sll_pkttype = 0; 749 ring->ll.sll_halen = 0; 750 751 ret = bind(sock, (struct sockaddr *) &ring->ll, sizeof(ring->ll)); 752 if (ret == -1) { 753 perror("bind"); 754 exit(1); 755 } 756 } 757 758 static void walk_ring(int sock, struct ring *ring) 759 { 760 ring->walk(sock, ring); 761 } 762 763 static void unmap_ring(int sock, struct ring *ring) 764 { 765 munmap(ring->mm_space, ring->mm_len); 766 free(ring->rd); 767 } 768 769 static int test_kernel_bit_width(void) 770 { 771 char in[512], *ptr; 772 int num = 0, fd; 773 ssize_t ret; 774 775 fd = open("/proc/kallsyms", O_RDONLY); 776 if (fd == -1) { 777 perror("open"); 778 exit(1); 779 } 780 781 ret = read(fd, in, sizeof(in)); 782 if (ret <= 0) { 783 perror("read"); 784 exit(1); 785 } 786 787 close(fd); 788 789 ptr = in; 790 while(!isspace(*ptr)) { 791 num++; 792 ptr++; 793 } 794 795 return num * 4; 796 } 797 798 static int test_user_bit_width(void) 799 { 800 return __WORDSIZE; 801 } 802 803 static const char *tpacket_str[] = { 804 [TPACKET_V1] = "TPACKET_V1", 805 [TPACKET_V2] = "TPACKET_V2", 806 [TPACKET_V3] = "TPACKET_V3", 807 }; 808 809 static const char *type_str[] = { 810 [PACKET_RX_RING] = "PACKET_RX_RING", 811 [PACKET_TX_RING] = "PACKET_TX_RING", 812 }; 813 814 static int test_tpacket(int version, int type) 815 { 816 int sock; 817 struct ring ring; 818 819 fprintf(stderr, "test: %s with %s ", tpacket_str[version], 820 type_str[type]); 821 fflush(stderr); 822 823 if (version == TPACKET_V1 && 824 test_kernel_bit_width() != test_user_bit_width()) { 825 fprintf(stderr, "test: skip %s %s since user and kernel " 826 "space have different bit width\n", 827 tpacket_str[version], type_str[type]); 828 return 0; 829 } 830 831 sock = pfsocket(version); 832 memset(&ring, 0, sizeof(ring)); 833 setup_ring(sock, &ring, version, type); 834 mmap_ring(sock, &ring); 835 bind_ring(sock, &ring); 836 walk_ring(sock, &ring); 837 unmap_ring(sock, &ring); 838 close(sock); 839 840 fprintf(stderr, "\n"); 841 return 0; 842 } 843 844 int main(void) 845 { 846 int ret = 0; 847 848 ret |= test_tpacket(TPACKET_V1, PACKET_RX_RING); 849 ret |= test_tpacket(TPACKET_V1, PACKET_TX_RING); 850 851 ret |= test_tpacket(TPACKET_V2, PACKET_RX_RING); 852 ret |= test_tpacket(TPACKET_V2, PACKET_TX_RING); 853 854 ret |= test_tpacket(TPACKET_V3, PACKET_RX_RING); 855 ret |= test_tpacket(TPACKET_V3, PACKET_TX_RING); 856 857 if (ret) 858 return 1; 859 860 printf("OK. All tests passed\n"); 861 return 0; 862 } 863