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