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

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

Version: ~ [ linux-6.0-rc6 ] ~ [ linux-5.19.10 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.69 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.144 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.214 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.259 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.294 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.329 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ 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.9 ] ~ [ 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, 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 }
806 

~ [ 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