~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/testing/selftests/net/psock_tpacket.c

Version: ~ [ linux-5.12-rc1 ] ~ [ linux-5.11.2 ] ~ [ linux-5.10.19 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.101 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.177 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.222 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.258 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.258 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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, 0);
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 
243         memset(&pfd, 0, sizeof(pfd));
244         pfd.fd = sock;
245         pfd.events = POLLIN | POLLERR;
246         pfd.revents = 0;
247 
248         pair_udp_send(udp_sock, NUM_PACKETS);
249 
250         while (total_packets < NUM_PACKETS * 2) {
251                 while (__v1_v2_rx_kernel_ready(ring->rd[frame_num].iov_base,
252                                                ring->version)) {
253                         ppd.raw = ring->rd[frame_num].iov_base;
254 
255                         switch (ring->version) {
256                         case TPACKET_V1:
257                                 test_payload((uint8_t *) ppd.raw + ppd.v1->tp_h.tp_mac,
258                                              ppd.v1->tp_h.tp_snaplen);
259                                 total_bytes += ppd.v1->tp_h.tp_snaplen;
260                                 break;
261 
262                         case TPACKET_V2:
263                                 test_payload((uint8_t *) ppd.raw + ppd.v2->tp_h.tp_mac,
264                                              ppd.v2->tp_h.tp_snaplen);
265                                 total_bytes += ppd.v2->tp_h.tp_snaplen;
266                                 break;
267                         }
268 
269                         status_bar_update();
270                         total_packets++;
271 
272                         __v1_v2_rx_user_ready(ppd.raw, ring->version);
273 
274                         frame_num = (frame_num + 1) % ring->rd_num;
275                 }
276 
277                 poll(&pfd, 1, 1);
278         }
279 
280         pair_udp_close(udp_sock);
281 
282         if (total_packets != 2 * NUM_PACKETS) {
283                 fprintf(stderr, "walk_v%d_rx: received %u out of %u pkts\n",
284                         ring->version, total_packets, NUM_PACKETS);
285                 exit(1);
286         }
287 
288         fprintf(stderr, " %u pkts (%u bytes)", NUM_PACKETS, total_bytes >> 1);
289 }
290 
291 static inline int __v1_tx_kernel_ready(struct tpacket_hdr *hdr)
292 {
293         return !(hdr->tp_status & (TP_STATUS_SEND_REQUEST | TP_STATUS_SENDING));
294 }
295 
296 static inline void __v1_tx_user_ready(struct tpacket_hdr *hdr)
297 {
298         hdr->tp_status = TP_STATUS_SEND_REQUEST;
299         __sync_synchronize();
300 }
301 
302 static inline int __v2_tx_kernel_ready(struct tpacket2_hdr *hdr)
303 {
304         return !(hdr->tp_status & (TP_STATUS_SEND_REQUEST | TP_STATUS_SENDING));
305 }
306 
307 static inline void __v2_tx_user_ready(struct tpacket2_hdr *hdr)
308 {
309         hdr->tp_status = TP_STATUS_SEND_REQUEST;
310         __sync_synchronize();
311 }
312 
313 static inline int __v3_tx_kernel_ready(struct tpacket3_hdr *hdr)
314 {
315         return !(hdr->tp_status & (TP_STATUS_SEND_REQUEST | TP_STATUS_SENDING));
316 }
317 
318 static inline void __v3_tx_user_ready(struct tpacket3_hdr *hdr)
319 {
320         hdr->tp_status = TP_STATUS_SEND_REQUEST;
321         __sync_synchronize();
322 }
323 
324 static inline int __tx_kernel_ready(void *base, int version)
325 {
326         switch (version) {
327         case TPACKET_V1:
328                 return __v1_tx_kernel_ready(base);
329         case TPACKET_V2:
330                 return __v2_tx_kernel_ready(base);
331         case TPACKET_V3:
332                 return __v3_tx_kernel_ready(base);
333         default:
334                 bug_on(1);
335                 return 0;
336         }
337 }
338 
339 static inline void __tx_user_ready(void *base, int version)
340 {
341         switch (version) {
342         case TPACKET_V1:
343                 __v1_tx_user_ready(base);
344                 break;
345         case TPACKET_V2:
346                 __v2_tx_user_ready(base);
347                 break;
348         case TPACKET_V3:
349                 __v3_tx_user_ready(base);
350                 break;
351         }
352 }
353 
354 static void __v1_v2_set_packet_loss_discard(int sock)
355 {
356         int ret, discard = 1;
357 
358         ret = setsockopt(sock, SOL_PACKET, PACKET_LOSS, (void *) &discard,
359                          sizeof(discard));
360         if (ret == -1) {
361                 perror("setsockopt");
362                 exit(1);
363         }
364 }
365 
366 static inline void *get_next_frame(struct ring *ring, int n)
367 {
368         uint8_t *f0 = ring->rd[0].iov_base;
369 
370         switch (ring->version) {
371         case TPACKET_V1:
372         case TPACKET_V2:
373                 return ring->rd[n].iov_base;
374         case TPACKET_V3:
375                 return f0 + (n * ring->req3.tp_frame_size);
376         default:
377                 bug_on(1);
378         }
379 }
380 
381 static void walk_tx(int sock, struct ring *ring)
382 {
383         struct pollfd pfd;
384         int rcv_sock, ret;
385         size_t packet_len;
386         union frame_map ppd;
387         char packet[1024];
388         unsigned int frame_num = 0, got = 0;
389         struct sockaddr_ll ll = {
390                 .sll_family = PF_PACKET,
391                 .sll_halen = ETH_ALEN,
392         };
393         int nframes;
394 
395         /* TPACKET_V{1,2} sets up the ring->rd* related variables based
396          * on frames (e.g., rd_num is tp_frame_nr) whereas V3 sets these
397          * up based on blocks (e.g, rd_num is  tp_block_nr)
398          */
399         if (ring->version <= TPACKET_V2)
400                 nframes = ring->rd_num;
401         else
402                 nframes = ring->req3.tp_frame_nr;
403 
404         bug_on(ring->type != PACKET_TX_RING);
405         bug_on(nframes < NUM_PACKETS);
406 
407         rcv_sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
408         if (rcv_sock == -1) {
409                 perror("socket");
410                 exit(1);
411         }
412 
413         pair_udp_setfilter(rcv_sock);
414 
415         ll.sll_ifindex = if_nametoindex("lo");
416         ret = bind(rcv_sock, (struct sockaddr *) &ll, sizeof(ll));
417         if (ret == -1) {
418                 perror("bind");
419                 exit(1);
420         }
421 
422         memset(&pfd, 0, sizeof(pfd));
423         pfd.fd = sock;
424         pfd.events = POLLOUT | POLLERR;
425         pfd.revents = 0;
426 
427         total_packets = NUM_PACKETS;
428         create_payload(packet, &packet_len);
429 
430         while (total_packets > 0) {
431                 void *next = get_next_frame(ring, frame_num);
432 
433                 while (__tx_kernel_ready(next, ring->version) &&
434                        total_packets > 0) {
435                         ppd.raw = next;
436 
437                         switch (ring->version) {
438                         case TPACKET_V1:
439                                 ppd.v1->tp_h.tp_snaplen = packet_len;
440                                 ppd.v1->tp_h.tp_len = packet_len;
441 
442                                 memcpy((uint8_t *) ppd.raw + TPACKET_HDRLEN -
443                                        sizeof(struct sockaddr_ll), packet,
444                                        packet_len);
445                                 total_bytes += ppd.v1->tp_h.tp_snaplen;
446                                 break;
447 
448                         case TPACKET_V2:
449                                 ppd.v2->tp_h.tp_snaplen = packet_len;
450                                 ppd.v2->tp_h.tp_len = packet_len;
451 
452                                 memcpy((uint8_t *) ppd.raw + TPACKET2_HDRLEN -
453                                        sizeof(struct sockaddr_ll), packet,
454                                        packet_len);
455                                 total_bytes += ppd.v2->tp_h.tp_snaplen;
456                                 break;
457                         case TPACKET_V3: {
458                                 struct tpacket3_hdr *tx = next;
459 
460                                 tx->tp_snaplen = packet_len;
461                                 tx->tp_len = packet_len;
462                                 tx->tp_next_offset = 0;
463 
464                                 memcpy((uint8_t *)tx + TPACKET3_HDRLEN -
465                                        sizeof(struct sockaddr_ll), packet,
466                                        packet_len);
467                                 total_bytes += tx->tp_snaplen;
468                                 break;
469                         }
470                         }
471 
472                         status_bar_update();
473                         total_packets--;
474 
475                         __tx_user_ready(next, ring->version);
476 
477                         frame_num = (frame_num + 1) % nframes;
478                 }
479 
480                 poll(&pfd, 1, 1);
481         }
482 
483         bug_on(total_packets != 0);
484 
485         ret = sendto(sock, NULL, 0, 0, NULL, 0);
486         if (ret == -1) {
487                 perror("sendto");
488                 exit(1);
489         }
490 
491         while ((ret = recvfrom(rcv_sock, packet, sizeof(packet),
492                                0, NULL, NULL)) > 0 &&
493                total_packets < NUM_PACKETS) {
494                 got += ret;
495                 test_payload(packet, ret);
496 
497                 status_bar_update();
498                 total_packets++;
499         }
500 
501         close(rcv_sock);
502 
503         if (total_packets != NUM_PACKETS) {
504                 fprintf(stderr, "walk_v%d_rx: received %u out of %u pkts\n",
505                         ring->version, total_packets, NUM_PACKETS);
506                 exit(1);
507         }
508 
509         fprintf(stderr, " %u pkts (%u bytes)", NUM_PACKETS, got);
510 }
511 
512 static void walk_v1_v2(int sock, struct ring *ring)
513 {
514         if (ring->type == PACKET_RX_RING)
515                 walk_v1_v2_rx(sock, ring);
516         else
517                 walk_tx(sock, ring);
518 }
519 
520 static uint64_t __v3_prev_block_seq_num = 0;
521 
522 void __v3_test_block_seq_num(struct block_desc *pbd)
523 {
524         if (__v3_prev_block_seq_num + 1 != pbd->h1.seq_num) {
525                 fprintf(stderr, "\nprev_block_seq_num:%"PRIu64", expected "
526                         "seq:%"PRIu64" != actual seq:%"PRIu64"\n",
527                         __v3_prev_block_seq_num, __v3_prev_block_seq_num + 1,
528                         (uint64_t) pbd->h1.seq_num);
529                 exit(1);
530         }
531 
532         __v3_prev_block_seq_num = pbd->h1.seq_num;
533 }
534 
535 static void __v3_test_block_len(struct block_desc *pbd, uint32_t bytes, int block_num)
536 {
537         if (pbd->h1.num_pkts && bytes != pbd->h1.blk_len) {
538                 fprintf(stderr, "\nblock:%u with %upackets, expected "
539                         "len:%u != actual len:%u\n", block_num,
540                         pbd->h1.num_pkts, bytes, pbd->h1.blk_len);
541                 exit(1);
542         }
543 }
544 
545 static void __v3_test_block_header(struct block_desc *pbd, const int block_num)
546 {
547         if ((pbd->h1.block_status & TP_STATUS_USER) == 0) {
548                 fprintf(stderr, "\nblock %u: not in TP_STATUS_USER\n", block_num);
549                 exit(1);
550         }
551 
552         __v3_test_block_seq_num(pbd);
553 }
554 
555 static void __v3_walk_block(struct block_desc *pbd, const int block_num)
556 {
557         int num_pkts = pbd->h1.num_pkts, i;
558         unsigned long bytes = 0, bytes_with_padding = ALIGN_8(sizeof(*pbd));
559         struct tpacket3_hdr *ppd;
560 
561         __v3_test_block_header(pbd, block_num);
562 
563         ppd = (struct tpacket3_hdr *) ((uint8_t *) pbd +
564                                        pbd->h1.offset_to_first_pkt);
565 
566         for (i = 0; i < num_pkts; ++i) {
567                 bytes += ppd->tp_snaplen;
568 
569                 if (ppd->tp_next_offset)
570                         bytes_with_padding += ppd->tp_next_offset;
571                 else
572                         bytes_with_padding += ALIGN_8(ppd->tp_snaplen + ppd->tp_mac);
573 
574                 test_payload((uint8_t *) ppd + ppd->tp_mac, ppd->tp_snaplen);
575 
576                 status_bar_update();
577                 total_packets++;
578 
579                 ppd = (struct tpacket3_hdr *) ((uint8_t *) ppd + ppd->tp_next_offset);
580                 __sync_synchronize();
581         }
582 
583         __v3_test_block_len(pbd, bytes_with_padding, block_num);
584         total_bytes += bytes;
585 }
586 
587 void __v3_flush_block(struct block_desc *pbd)
588 {
589         pbd->h1.block_status = TP_STATUS_KERNEL;
590         __sync_synchronize();
591 }
592 
593 static void walk_v3_rx(int sock, struct ring *ring)
594 {
595         unsigned int block_num = 0;
596         struct pollfd pfd;
597         struct block_desc *pbd;
598         int udp_sock[2];
599 
600         bug_on(ring->type != PACKET_RX_RING);
601 
602         pair_udp_open(udp_sock, PORT_BASE);
603 
604         memset(&pfd, 0, sizeof(pfd));
605         pfd.fd = sock;
606         pfd.events = POLLIN | POLLERR;
607         pfd.revents = 0;
608 
609         pair_udp_send(udp_sock, NUM_PACKETS);
610 
611         while (total_packets < NUM_PACKETS * 2) {
612                 pbd = (struct block_desc *) ring->rd[block_num].iov_base;
613 
614                 while ((pbd->h1.block_status & TP_STATUS_USER) == 0)
615                         poll(&pfd, 1, 1);
616 
617                 __v3_walk_block(pbd, block_num);
618                 __v3_flush_block(pbd);
619 
620                 block_num = (block_num + 1) % ring->rd_num;
621         }
622 
623         pair_udp_close(udp_sock);
624 
625         if (total_packets != 2 * NUM_PACKETS) {
626                 fprintf(stderr, "walk_v3_rx: received %u out of %u pkts\n",
627                         total_packets, NUM_PACKETS);
628                 exit(1);
629         }
630 
631         fprintf(stderr, " %u pkts (%u bytes)", NUM_PACKETS, total_bytes >> 1);
632 }
633 
634 static void walk_v3(int sock, struct ring *ring)
635 {
636         if (ring->type == PACKET_RX_RING)
637                 walk_v3_rx(sock, ring);
638         else
639                 walk_tx(sock, ring);
640 }
641 
642 static void __v1_v2_fill(struct ring *ring, unsigned int blocks)
643 {
644         ring->req.tp_block_size = getpagesize() << 2;
645         ring->req.tp_frame_size = TPACKET_ALIGNMENT << 7;
646         ring->req.tp_block_nr = blocks;
647 
648         ring->req.tp_frame_nr = ring->req.tp_block_size /
649                                 ring->req.tp_frame_size *
650                                 ring->req.tp_block_nr;
651 
652         ring->mm_len = ring->req.tp_block_size * ring->req.tp_block_nr;
653         ring->walk = walk_v1_v2;
654         ring->rd_num = ring->req.tp_frame_nr;
655         ring->flen = ring->req.tp_frame_size;
656 }
657 
658 static void __v3_fill(struct ring *ring, unsigned int blocks, int type)
659 {
660         if (type == PACKET_RX_RING) {
661                 ring->req3.tp_retire_blk_tov = 64;
662                 ring->req3.tp_sizeof_priv = 0;
663                 ring->req3.tp_feature_req_word = TP_FT_REQ_FILL_RXHASH;
664         }
665         ring->req3.tp_block_size = getpagesize() << 2;
666         ring->req3.tp_frame_size = TPACKET_ALIGNMENT << 7;
667         ring->req3.tp_block_nr = blocks;
668 
669         ring->req3.tp_frame_nr = ring->req3.tp_block_size /
670                                  ring->req3.tp_frame_size *
671                                  ring->req3.tp_block_nr;
672 
673         ring->mm_len = ring->req3.tp_block_size * ring->req3.tp_block_nr;
674         ring->walk = walk_v3;
675         ring->rd_num = ring->req3.tp_block_nr;
676         ring->flen = ring->req3.tp_block_size;
677 }
678 
679 static void setup_ring(int sock, struct ring *ring, int version, int type)
680 {
681         int ret = 0;
682         unsigned int blocks = 256;
683 
684         ring->type = type;
685         ring->version = version;
686 
687         switch (version) {
688         case TPACKET_V1:
689         case TPACKET_V2:
690                 if (type == PACKET_TX_RING)
691                         __v1_v2_set_packet_loss_discard(sock);
692                 __v1_v2_fill(ring, blocks);
693                 ret = setsockopt(sock, SOL_PACKET, type, &ring->req,
694                                  sizeof(ring->req));
695                 break;
696 
697         case TPACKET_V3:
698                 __v3_fill(ring, blocks, type);
699                 ret = setsockopt(sock, SOL_PACKET, type, &ring->req3,
700                                  sizeof(ring->req3));
701                 break;
702         }
703 
704         if (ret == -1) {
705                 perror("setsockopt");
706                 exit(1);
707         }
708 
709         ring->rd_len = ring->rd_num * sizeof(*ring->rd);
710         ring->rd = malloc(ring->rd_len);
711         if (ring->rd == NULL) {
712                 perror("malloc");
713                 exit(1);
714         }
715 
716         total_packets = 0;
717         total_bytes = 0;
718 }
719 
720 static void mmap_ring(int sock, struct ring *ring)
721 {
722         int i;
723 
724         ring->mm_space = mmap(0, ring->mm_len, PROT_READ | PROT_WRITE,
725                               MAP_SHARED | MAP_LOCKED | MAP_POPULATE, sock, 0);
726         if (ring->mm_space == MAP_FAILED) {
727                 perror("mmap");
728                 exit(1);
729         }
730 
731         memset(ring->rd, 0, ring->rd_len);
732         for (i = 0; i < ring->rd_num; ++i) {
733                 ring->rd[i].iov_base = ring->mm_space + (i * ring->flen);
734                 ring->rd[i].iov_len = ring->flen;
735         }
736 }
737 
738 static void bind_ring(int sock, struct ring *ring)
739 {
740         int ret;
741 
742         pair_udp_setfilter(sock);
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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp