Loading...
1.. SPDX-License-Identifier: GPL-2.0
2
3===========
4Packet MMAP
5===========
6
7Abstract
8========
9
10This file documents the mmap() facility available with the PACKET
11socket interface. This type of sockets is used for
12
13i) capture network traffic with utilities like tcpdump,
14ii) transmit network traffic, or any other that needs raw
15 access to network interface.
16
17Howto can be found at:
18
19 https://web.archive.org/web/20220404160947/https://sites.google.com/site/packetmmap/
20
21Please send your comments to
22 - Ulisses Alonso Camaró <uaca@i.hate.spam.alumni.uv.es>
23 - Johann Baudy
24
25Why use PACKET_MMAP
26===================
27
28Non PACKET_MMAP capture process (plain AF_PACKET) is very
29inefficient. It uses very limited buffers and requires one system call to
30capture each packet, it requires two if you want to get packet's timestamp
31(like libpcap always does).
32
33On the other hand PACKET_MMAP is very efficient. PACKET_MMAP provides a size
34configurable circular buffer mapped in user space that can be used to either
35send or receive packets. This way reading packets just needs to wait for them,
36most of the time there is no need to issue a single system call. Concerning
37transmission, multiple packets can be sent through one system call to get the
38highest bandwidth. By using a shared buffer between the kernel and the user
39also has the benefit of minimizing packet copies.
40
41It's fine to use PACKET_MMAP to improve the performance of the capture and
42transmission process, but it isn't everything. At least, if you are capturing
43at high speeds (this is relative to the cpu speed), you should check if the
44device driver of your network interface card supports some sort of interrupt
45load mitigation or (even better) if it supports NAPI, also make sure it is
46enabled. For transmission, check the MTU (Maximum Transmission Unit) used and
47supported by devices of your network. CPU IRQ pinning of your network interface
48card can also be an advantage.
49
50How to use mmap() to improve capture process
51============================================
52
53From the user standpoint, you should use the higher level libpcap library, which
54is a de facto standard, portable across nearly all operating systems
55including Win32.
56
57Packet MMAP support was integrated into libpcap around the time of version 1.3.0;
58TPACKET_V3 support was added in version 1.5.0
59
60How to use mmap() directly to improve capture process
61=====================================================
62
63From the system calls stand point, the use of PACKET_MMAP involves
64the following process::
65
66
67 [setup] socket() -------> creation of the capture socket
68 setsockopt() ---> allocation of the circular buffer (ring)
69 option: PACKET_RX_RING
70 mmap() ---------> mapping of the allocated buffer to the
71 user process
72
73 [capture] poll() ---------> to wait for incoming packets
74
75 [shutdown] close() --------> destruction of the capture socket and
76 deallocation of all associated
77 resources.
78
79
80socket creation and destruction is straight forward, and is done
81the same way with or without PACKET_MMAP::
82
83 int fd = socket(PF_PACKET, mode, htons(ETH_P_ALL));
84
85where mode is SOCK_RAW for the raw interface were link level
86information can be captured or SOCK_DGRAM for the cooked
87interface where link level information capture is not
88supported and a link level pseudo-header is provided
89by the kernel.
90
91The destruction of the socket and all associated resources
92is done by a simple call to close(fd).
93
94Similarly as without PACKET_MMAP, it is possible to use one socket
95for capture and transmission. This can be done by mapping the
96allocated RX and TX buffer ring with a single mmap() call.
97See "Mapping and use of the circular buffer (ring)".
98
99Next I will describe PACKET_MMAP settings and its constraints,
100also the mapping of the circular buffer in the user process and
101the use of this buffer.
102
103How to use mmap() directly to improve transmission process
104==========================================================
105Transmission process is similar to capture as shown below::
106
107 [setup] socket() -------> creation of the transmission socket
108 setsockopt() ---> allocation of the circular buffer (ring)
109 option: PACKET_TX_RING
110 bind() ---------> bind transmission socket with a network interface
111 mmap() ---------> mapping of the allocated buffer to the
112 user process
113
114 [transmission] poll() ---------> wait for free packets (optional)
115 send() ---------> send all packets that are set as ready in
116 the ring
117 The flag MSG_DONTWAIT can be used to return
118 before end of transfer.
119
120 [shutdown] close() --------> destruction of the transmission socket and
121 deallocation of all associated resources.
122
123Socket creation and destruction is also straight forward, and is done
124the same way as in capturing described in the previous paragraph::
125
126 int fd = socket(PF_PACKET, mode, 0);
127
128The protocol can optionally be 0 in case we only want to transmit
129via this socket, which avoids an expensive call to packet_rcv().
130In this case, you also need to bind(2) the TX_RING with sll_protocol = 0
131set. Otherwise, htons(ETH_P_ALL) or any other protocol, for example.
132
133Binding the socket to your network interface is mandatory (with zero copy) to
134know the header size of frames used in the circular buffer.
135
136As capture, each frame contains two parts::
137
138 --------------------
139 | struct tpacket_hdr | Header. It contains the status of
140 | | of this frame
141 |--------------------|
142 | data buffer |
143 . . Data that will be sent over the network interface.
144 . .
145 --------------------
146
147 bind() associates the socket to your network interface thanks to
148 sll_ifindex parameter of struct sockaddr_ll.
149
150 Initialization example::
151
152 struct sockaddr_ll my_addr;
153 struct ifreq s_ifr;
154 ...
155
156 strscpy_pad (s_ifr.ifr_name, "eth0", sizeof(s_ifr.ifr_name));
157
158 /* get interface index of eth0 */
159 ioctl(this->socket, SIOCGIFINDEX, &s_ifr);
160
161 /* fill sockaddr_ll struct to prepare binding */
162 my_addr.sll_family = AF_PACKET;
163 my_addr.sll_protocol = htons(ETH_P_ALL);
164 my_addr.sll_ifindex = s_ifr.ifr_ifindex;
165
166 /* bind socket to eth0 */
167 bind(this->socket, (struct sockaddr *)&my_addr, sizeof(struct sockaddr_ll));
168
169 A complete tutorial is available at:
170 https://web.archive.org/web/20220404160947/https://sites.google.com/site/packetmmap/
171
172By default, the user should put data at::
173
174 frame base + TPACKET_HDRLEN - sizeof(struct sockaddr_ll)
175
176So, whatever you choose for the socket mode (SOCK_DGRAM or SOCK_RAW),
177the beginning of the user data will be at::
178
179 frame base + TPACKET_ALIGN(sizeof(struct tpacket_hdr))
180
181If you wish to put user data at a custom offset from the beginning of
182the frame (for payload alignment with SOCK_RAW mode for instance) you
183can set tp_net (with SOCK_DGRAM) or tp_mac (with SOCK_RAW). In order
184to make this work it must be enabled previously with setsockopt()
185and the PACKET_TX_HAS_OFF option.
186
187PACKET_MMAP settings
188====================
189
190To setup PACKET_MMAP from user level code is done with a call like
191
192 - Capture process::
193
194 setsockopt(fd, SOL_PACKET, PACKET_RX_RING, (void *) &req, sizeof(req))
195
196 - Transmission process::
197
198 setsockopt(fd, SOL_PACKET, PACKET_TX_RING, (void *) &req, sizeof(req))
199
200The most significant argument in the previous call is the req parameter,
201this parameter must to have the following structure::
202
203 struct tpacket_req
204 {
205 unsigned int tp_block_size; /* Minimal size of contiguous block */
206 unsigned int tp_block_nr; /* Number of blocks */
207 unsigned int tp_frame_size; /* Size of frame */
208 unsigned int tp_frame_nr; /* Total number of frames */
209 };
210
211This structure is defined in /usr/include/linux/if_packet.h and establishes a
212circular buffer (ring) of unswappable memory.
213Being mapped in the capture process allows reading the captured frames and
214related meta-information like timestamps without requiring a system call.
215
216Frames are grouped in blocks. Each block is a physically contiguous
217region of memory and holds tp_block_size/tp_frame_size frames. The total number
218of blocks is tp_block_nr. Note that tp_frame_nr is a redundant parameter because::
219
220 frames_per_block = tp_block_size/tp_frame_size
221
222indeed, packet_set_ring checks that the following condition is true::
223
224 frames_per_block * tp_block_nr == tp_frame_nr
225
226Lets see an example, with the following values::
227
228 tp_block_size= 4096
229 tp_frame_size= 2048
230 tp_block_nr = 4
231 tp_frame_nr = 8
232
233we will get the following buffer structure::
234
235 block #1 block #2
236 +---------+---------+ +---------+---------+
237 | frame 1 | frame 2 | | frame 3 | frame 4 |
238 +---------+---------+ +---------+---------+
239
240 block #3 block #4
241 +---------+---------+ +---------+---------+
242 | frame 5 | frame 6 | | frame 7 | frame 8 |
243 +---------+---------+ +---------+---------+
244
245A frame can be of any size with the only condition it can fit in a block. A block
246can only hold an integer number of frames, or in other words, a frame cannot
247be spawned across two blocks, so there are some details you have to take into
248account when choosing the frame_size. See "Mapping and use of the circular
249buffer (ring)".
250
251PACKET_MMAP setting constraints
252===============================
253
254In kernel versions prior to 2.4.26 (for the 2.4 branch) and 2.6.5 (2.6 branch),
255the PACKET_MMAP buffer could hold only 32768 frames in a 32 bit architecture or
25616384 in a 64 bit architecture.
257
258Block size limit
259----------------
260
261As stated earlier, each block is a contiguous physical region of memory. These
262memory regions are allocated with calls to the __get_free_pages() function. As
263the name indicates, this function allocates pages of memory, and the second
264argument is "order" or a power of two number of pages, that is
265(for PAGE_SIZE == 4096) order=0 ==> 4096 bytes, order=1 ==> 8192 bytes,
266order=2 ==> 16384 bytes, etc. The maximum size of a
267region allocated by __get_free_pages is determined by the MAX_PAGE_ORDER macro.
268More precisely the limit can be calculated as::
269
270 PAGE_SIZE << MAX_PAGE_ORDER
271
272 In a i386 architecture PAGE_SIZE is 4096 bytes
273 In a 2.4/i386 kernel MAX_PAGE_ORDER is 10
274 In a 2.6/i386 kernel MAX_PAGE_ORDER is 11
275
276So get_free_pages can allocate as much as 4MB or 8MB in a 2.4/2.6 kernel
277respectively, with an i386 architecture.
278
279User space programs can include /usr/include/sys/user.h and
280/usr/include/linux/mmzone.h to get PAGE_SIZE MAX_PAGE_ORDER declarations.
281
282The pagesize can also be determined dynamically with the getpagesize (2)
283system call.
284
285Block number limit
286------------------
287
288To understand the constraints of PACKET_MMAP, we have to see the structure
289used to hold the pointers to each block.
290
291Currently, this structure is a dynamically allocated vector with kmalloc
292called pg_vec, its size limits the number of blocks that can be allocated::
293
294 +---+---+---+---+
295 | x | x | x | x |
296 +---+---+---+---+
297 | | | |
298 | | | v
299 | | v block #4
300 | v block #3
301 v block #2
302 block #1
303
304kmalloc allocates any number of bytes of physically contiguous memory from
305a pool of pre-determined sizes. This pool of memory is maintained by the slab
306allocator which is at the end the responsible for doing the allocation and
307hence which imposes the maximum memory that kmalloc can allocate.
308
309In a 2.4/2.6 kernel and the i386 architecture, the limit is 131072 bytes. The
310predetermined sizes that kmalloc uses can be checked in the "size-<bytes>"
311entries of /proc/slabinfo
312
313In a 32 bit architecture, pointers are 4 bytes long, so the total number of
314pointers to blocks is::
315
316 131072/4 = 32768 blocks
317
318PACKET_MMAP buffer size calculator
319==================================
320
321Definitions:
322
323============== ================================================================
324<size-max> is the maximum size of allocable with kmalloc
325 (see /proc/slabinfo)
326<pointer size> depends on the architecture -- ``sizeof(void *)``
327<page size> depends on the architecture -- PAGE_SIZE or getpagesize (2)
328<max-order> is the value defined with MAX_PAGE_ORDER
329<frame size> it's an upper bound of frame's capture size (more on this later)
330============== ================================================================
331
332from these definitions we will derive::
333
334 <block number> = <size-max>/<pointer size>
335 <block size> = <pagesize> << <max-order>
336
337so, the max buffer size is::
338
339 <block number> * <block size>
340
341and, the number of frames be::
342
343 <block number> * <block size> / <frame size>
344
345Suppose the following parameters, which apply for 2.6 kernel and an
346i386 architecture::
347
348 <size-max> = 131072 bytes
349 <pointer size> = 4 bytes
350 <pagesize> = 4096 bytes
351 <max-order> = 11
352
353and a value for <frame size> of 2048 bytes. These parameters will yield::
354
355 <block number> = 131072/4 = 32768 blocks
356 <block size> = 4096 << 11 = 8 MiB.
357
358and hence the buffer will have a 262144 MiB size. So it can hold
359262144 MiB / 2048 bytes = 134217728 frames
360
361Actually, this buffer size is not possible with an i386 architecture.
362Remember that the memory is allocated in kernel space, in the case of
363an i386 kernel's memory size is limited to 1GiB.
364
365All memory allocations are not freed until the socket is closed. The memory
366allocations are done with GFP_KERNEL priority, this basically means that
367the allocation can wait and swap other process' memory in order to allocate
368the necessary memory, so normally limits can be reached.
369
370Other constraints
371-----------------
372
373If you check the source code you will see that what I draw here as a frame
374is not only the link level frame. At the beginning of each frame there is a
375header called struct tpacket_hdr used in PACKET_MMAP to hold link level's frame
376meta information like timestamp. So what we draw here a frame it's really
377the following (from include/linux/if_packet.h)::
378
379 /*
380 Frame structure:
381
382 - Start. Frame must be aligned to TPACKET_ALIGNMENT=16
383 - struct tpacket_hdr
384 - pad to TPACKET_ALIGNMENT=16
385 - struct sockaddr_ll
386 - Gap, chosen so that packet data (Start+tp_net) aligns to
387 TPACKET_ALIGNMENT=16
388 - Start+tp_mac: [ Optional MAC header ]
389 - Start+tp_net: Packet data, aligned to TPACKET_ALIGNMENT=16.
390 - Pad to align to TPACKET_ALIGNMENT=16
391 */
392
393The following are conditions that are checked in packet_set_ring
394
395 - tp_block_size must be a multiple of PAGE_SIZE (1)
396 - tp_frame_size must be greater than TPACKET_HDRLEN (obvious)
397 - tp_frame_size must be a multiple of TPACKET_ALIGNMENT
398 - tp_frame_nr must be exactly frames_per_block*tp_block_nr
399
400Note that tp_block_size should be chosen to be a power of two or there will
401be a waste of memory.
402
403Mapping and use of the circular buffer (ring)
404---------------------------------------------
405
406The mapping of the buffer in the user process is done with the conventional
407mmap function. Even the circular buffer is compound of several physically
408discontiguous blocks of memory, they are contiguous to the user space, hence
409just one call to mmap is needed::
410
411 mmap(0, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
412
413If tp_frame_size is a divisor of tp_block_size frames will be
414contiguously spaced by tp_frame_size bytes. If not, each
415tp_block_size/tp_frame_size frames there will be a gap between
416the frames. This is because a frame cannot be spawn across two
417blocks.
418
419To use one socket for capture and transmission, the mapping of both the
420RX and TX buffer ring has to be done with one call to mmap::
421
422 ...
423 setsockopt(fd, SOL_PACKET, PACKET_RX_RING, &foo, sizeof(foo));
424 setsockopt(fd, SOL_PACKET, PACKET_TX_RING, &bar, sizeof(bar));
425 ...
426 rx_ring = mmap(0, size * 2, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
427 tx_ring = rx_ring + size;
428
429RX must be the first as the kernel maps the TX ring memory right
430after the RX one.
431
432At the beginning of each frame there is an status field (see
433struct tpacket_hdr). If this field is 0 means that the frame is ready
434to be used for the kernel, If not, there is a frame the user can read
435and the following flags apply:
436
437Capture process
438^^^^^^^^^^^^^^^
439
440From include/linux/if_packet.h::
441
442 #define TP_STATUS_COPY (1 << 1)
443 #define TP_STATUS_LOSING (1 << 2)
444 #define TP_STATUS_CSUMNOTREADY (1 << 3)
445 #define TP_STATUS_CSUM_VALID (1 << 7)
446
447====================== =======================================================
448TP_STATUS_COPY This flag indicates that the frame (and associated
449 meta information) has been truncated because it's
450 larger than tp_frame_size. This packet can be
451 read entirely with recvfrom().
452
453 In order to make this work it must to be
454 enabled previously with setsockopt() and
455 the PACKET_COPY_THRESH option.
456
457 The number of frames that can be buffered to
458 be read with recvfrom is limited like a normal socket.
459 See the SO_RCVBUF option in the socket (7) man page.
460
461TP_STATUS_LOSING indicates there were packet drops from last time
462 statistics where checked with getsockopt() and
463 the PACKET_STATISTICS option.
464
465TP_STATUS_CSUMNOTREADY currently it's used for outgoing IP packets which
466 its checksum will be done in hardware. So while
467 reading the packet we should not try to check the
468 checksum.
469
470TP_STATUS_CSUM_VALID This flag indicates that at least the transport
471 header checksum of the packet has been already
472 validated on the kernel side. If the flag is not set
473 then we are free to check the checksum by ourselves
474 provided that TP_STATUS_CSUMNOTREADY is also not set.
475====================== =======================================================
476
477for convenience there are also the following defines::
478
479 #define TP_STATUS_KERNEL 0
480 #define TP_STATUS_USER 1
481
482The kernel initializes all frames to TP_STATUS_KERNEL, when the kernel
483receives a packet it puts in the buffer and updates the status with
484at least the TP_STATUS_USER flag. Then the user can read the packet,
485once the packet is read the user must zero the status field, so the kernel
486can use again that frame buffer.
487
488The user can use poll (any other variant should apply too) to check if new
489packets are in the ring::
490
491 struct pollfd pfd;
492
493 pfd.fd = fd;
494 pfd.revents = 0;
495 pfd.events = POLLIN|POLLRDNORM|POLLERR;
496
497 if (status == TP_STATUS_KERNEL)
498 retval = poll(&pfd, 1, timeout);
499
500It doesn't incur in a race condition to first check the status value and
501then poll for frames.
502
503Transmission process
504^^^^^^^^^^^^^^^^^^^^
505
506Those defines are also used for transmission::
507
508 #define TP_STATUS_AVAILABLE 0 // Frame is available
509 #define TP_STATUS_SEND_REQUEST 1 // Frame will be sent on next send()
510 #define TP_STATUS_SENDING 2 // Frame is currently in transmission
511 #define TP_STATUS_WRONG_FORMAT 4 // Frame format is not correct
512
513First, the kernel initializes all frames to TP_STATUS_AVAILABLE. To send a
514packet, the user fills a data buffer of an available frame, sets tp_len to
515current data buffer size and sets its status field to TP_STATUS_SEND_REQUEST.
516This can be done on multiple frames. Once the user is ready to transmit, it
517calls send(). Then all buffers with status equal to TP_STATUS_SEND_REQUEST are
518forwarded to the network device. The kernel updates each status of sent
519frames with TP_STATUS_SENDING until the end of transfer.
520
521At the end of each transfer, buffer status returns to TP_STATUS_AVAILABLE.
522
523::
524
525 header->tp_len = in_i_size;
526 header->tp_status = TP_STATUS_SEND_REQUEST;
527 retval = send(this->socket, NULL, 0, 0);
528
529The user can also use poll() to check if a buffer is available:
530
531(status == TP_STATUS_SENDING)
532
533::
534
535 struct pollfd pfd;
536 pfd.fd = fd;
537 pfd.revents = 0;
538 pfd.events = POLLOUT;
539 retval = poll(&pfd, 1, timeout);
540
541What TPACKET versions are available and when to use them?
542=========================================================
543
544::
545
546 int val = tpacket_version;
547 setsockopt(fd, SOL_PACKET, PACKET_VERSION, &val, sizeof(val));
548 getsockopt(fd, SOL_PACKET, PACKET_VERSION, &val, sizeof(val));
549
550where 'tpacket_version' can be TPACKET_V1 (default), TPACKET_V2, TPACKET_V3.
551
552TPACKET_V1:
553 - Default if not otherwise specified by setsockopt(2)
554 - RX_RING, TX_RING available
555
556TPACKET_V1 --> TPACKET_V2:
557 - Made 64 bit clean due to unsigned long usage in TPACKET_V1
558 structures, thus this also works on 64 bit kernel with 32 bit
559 userspace and the like
560 - Timestamp resolution in nanoseconds instead of microseconds
561 - RX_RING, TX_RING available
562 - VLAN metadata information available for packets
563 (TP_STATUS_VLAN_VALID, TP_STATUS_VLAN_TPID_VALID),
564 in the tpacket2_hdr structure:
565
566 - TP_STATUS_VLAN_VALID bit being set into the tp_status field indicates
567 that the tp_vlan_tci field has valid VLAN TCI value
568 - TP_STATUS_VLAN_TPID_VALID bit being set into the tp_status field
569 indicates that the tp_vlan_tpid field has valid VLAN TPID value
570
571 - How to switch to TPACKET_V2:
572
573 1. Replace struct tpacket_hdr by struct tpacket2_hdr
574 2. Query header len and save
575 3. Set protocol version to 2, set up ring as usual
576 4. For getting the sockaddr_ll,
577 use ``(void *)hdr + TPACKET_ALIGN(hdrlen)`` instead of
578 ``(void *)hdr + TPACKET_ALIGN(sizeof(struct tpacket_hdr))``
579
580TPACKET_V2 --> TPACKET_V3:
581 - Flexible buffer implementation for RX_RING:
582 1. Blocks can be configured with non-static frame-size
583 2. Read/poll is at a block-level (as opposed to packet-level)
584 3. Added poll timeout to avoid indefinite user-space wait
585 on idle links
586 4. Added user-configurable knobs:
587
588 4.1 block::timeout
589 4.2 tpkt_hdr::sk_rxhash
590
591 - RX Hash data available in user space
592 - TX_RING semantics are conceptually similar to TPACKET_V2;
593 use tpacket3_hdr instead of tpacket2_hdr, and TPACKET3_HDRLEN
594 instead of TPACKET2_HDRLEN. In the current implementation,
595 the tp_next_offset field in the tpacket3_hdr MUST be set to
596 zero, indicating that the ring does not hold variable sized frames.
597 Packets with non-zero values of tp_next_offset will be dropped.
598
599AF_PACKET fanout mode
600=====================
601
602In the AF_PACKET fanout mode, packet reception can be load balanced among
603processes. This also works in combination with mmap(2) on packet sockets.
604
605Currently implemented fanout policies are:
606
607 - PACKET_FANOUT_HASH: schedule to socket by skb's packet hash
608 - PACKET_FANOUT_LB: schedule to socket by round-robin
609 - PACKET_FANOUT_CPU: schedule to socket by CPU packet arrives on
610 - PACKET_FANOUT_RND: schedule to socket by random selection
611 - PACKET_FANOUT_ROLLOVER: if one socket is full, rollover to another
612 - PACKET_FANOUT_QM: schedule to socket by skbs recorded queue_mapping
613
614Minimal example code by David S. Miller (try things like "./test eth0 hash",
615"./test eth0 lb", etc.)::
616
617 #include <stddef.h>
618 #include <stdlib.h>
619 #include <stdio.h>
620 #include <string.h>
621
622 #include <sys/types.h>
623 #include <sys/wait.h>
624 #include <sys/socket.h>
625 #include <sys/ioctl.h>
626
627 #include <unistd.h>
628
629 #include <linux/if_ether.h>
630 #include <linux/if_packet.h>
631
632 #include <net/if.h>
633
634 static const char *device_name;
635 static int fanout_type;
636 static int fanout_id;
637
638 #ifndef PACKET_FANOUT
639 # define PACKET_FANOUT 18
640 # define PACKET_FANOUT_HASH 0
641 # define PACKET_FANOUT_LB 1
642 #endif
643
644 static int setup_socket(void)
645 {
646 int err, fd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_IP));
647 struct sockaddr_ll ll;
648 struct ifreq ifr;
649 int fanout_arg;
650
651 if (fd < 0) {
652 perror("socket");
653 return EXIT_FAILURE;
654 }
655
656 memset(&ifr, 0, sizeof(ifr));
657 strcpy(ifr.ifr_name, device_name);
658 err = ioctl(fd, SIOCGIFINDEX, &ifr);
659 if (err < 0) {
660 perror("SIOCGIFINDEX");
661 return EXIT_FAILURE;
662 }
663
664 memset(&ll, 0, sizeof(ll));
665 ll.sll_family = AF_PACKET;
666 ll.sll_ifindex = ifr.ifr_ifindex;
667 err = bind(fd, (struct sockaddr *) &ll, sizeof(ll));
668 if (err < 0) {
669 perror("bind");
670 return EXIT_FAILURE;
671 }
672
673 fanout_arg = (fanout_id | (fanout_type << 16));
674 err = setsockopt(fd, SOL_PACKET, PACKET_FANOUT,
675 &fanout_arg, sizeof(fanout_arg));
676 if (err) {
677 perror("setsockopt");
678 return EXIT_FAILURE;
679 }
680
681 return fd;
682 }
683
684 static void fanout_thread(void)
685 {
686 int fd = setup_socket();
687 int limit = 10000;
688
689 if (fd < 0)
690 exit(fd);
691
692 while (limit-- > 0) {
693 char buf[1600];
694 int err;
695
696 err = read(fd, buf, sizeof(buf));
697 if (err < 0) {
698 perror("read");
699 exit(EXIT_FAILURE);
700 }
701 if ((limit % 10) == 0)
702 fprintf(stdout, "(%d) \n", getpid());
703 }
704
705 fprintf(stdout, "%d: Received 10000 packets\n", getpid());
706
707 close(fd);
708 exit(0);
709 }
710
711 int main(int argc, char **argp)
712 {
713 int fd, err;
714 int i;
715
716 if (argc != 3) {
717 fprintf(stderr, "Usage: %s INTERFACE {hash|lb}\n", argp[0]);
718 return EXIT_FAILURE;
719 }
720
721 if (!strcmp(argp[2], "hash"))
722 fanout_type = PACKET_FANOUT_HASH;
723 else if (!strcmp(argp[2], "lb"))
724 fanout_type = PACKET_FANOUT_LB;
725 else {
726 fprintf(stderr, "Unknown fanout type [%s]\n", argp[2]);
727 exit(EXIT_FAILURE);
728 }
729
730 device_name = argp[1];
731 fanout_id = getpid() & 0xffff;
732
733 for (i = 0; i < 4; i++) {
734 pid_t pid = fork();
735
736 switch (pid) {
737 case 0:
738 fanout_thread();
739
740 case -1:
741 perror("fork");
742 exit(EXIT_FAILURE);
743 }
744 }
745
746 for (i = 0; i < 4; i++) {
747 int status;
748
749 wait(&status);
750 }
751
752 return 0;
753 }
754
755AF_PACKET TPACKET_V3 example
756============================
757
758AF_PACKET's TPACKET_V3 ring buffer can be configured to use non-static frame
759sizes by doing its own memory management. It is based on blocks where polling
760works on a per block basis instead of per ring as in TPACKET_V2 and predecessor.
761
762It is said that TPACKET_V3 brings the following benefits:
763
764 * ~15% - 20% reduction in CPU-usage
765 * ~20% increase in packet capture rate
766 * ~2x increase in packet density
767 * Port aggregation analysis
768 * Non static frame size to capture entire packet payload
769
770So it seems to be a good candidate to be used with packet fanout.
771
772Minimal example code by Daniel Borkmann based on Chetan Loke's lolpcap (compile
773it with gcc -Wall -O2 blob.c, and try things like "./a.out eth0", etc.)::
774
775 /* Written from scratch, but kernel-to-user space API usage
776 * dissected from lolpcap:
777 * Copyright 2011, Chetan Loke <loke.chetan@gmail.com>
778 * License: GPL, version 2.0
779 */
780
781 #include <stdio.h>
782 #include <stdlib.h>
783 #include <stdint.h>
784 #include <string.h>
785 #include <assert.h>
786 #include <net/if.h>
787 #include <arpa/inet.h>
788 #include <netdb.h>
789 #include <poll.h>
790 #include <unistd.h>
791 #include <signal.h>
792 #include <inttypes.h>
793 #include <sys/socket.h>
794 #include <sys/mman.h>
795 #include <linux/if_packet.h>
796 #include <linux/if_ether.h>
797 #include <linux/ip.h>
798
799 #ifndef likely
800 # define likely(x) __builtin_expect(!!(x), 1)
801 #endif
802 #ifndef unlikely
803 # define unlikely(x) __builtin_expect(!!(x), 0)
804 #endif
805
806 struct block_desc {
807 uint32_t version;
808 uint32_t offset_to_priv;
809 struct tpacket_hdr_v1 h1;
810 };
811
812 struct ring {
813 struct iovec *rd;
814 uint8_t *map;
815 struct tpacket_req3 req;
816 };
817
818 static unsigned long packets_total = 0, bytes_total = 0;
819 static sig_atomic_t sigint = 0;
820
821 static void sighandler(int num)
822 {
823 sigint = 1;
824 }
825
826 static int setup_socket(struct ring *ring, char *netdev)
827 {
828 int err, i, fd, v = TPACKET_V3;
829 struct sockaddr_ll ll;
830 unsigned int blocksiz = 1 << 22, framesiz = 1 << 11;
831 unsigned int blocknum = 64;
832
833 fd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
834 if (fd < 0) {
835 perror("socket");
836 exit(1);
837 }
838
839 err = setsockopt(fd, SOL_PACKET, PACKET_VERSION, &v, sizeof(v));
840 if (err < 0) {
841 perror("setsockopt");
842 exit(1);
843 }
844
845 memset(&ring->req, 0, sizeof(ring->req));
846 ring->req.tp_block_size = blocksiz;
847 ring->req.tp_frame_size = framesiz;
848 ring->req.tp_block_nr = blocknum;
849 ring->req.tp_frame_nr = (blocksiz * blocknum) / framesiz;
850 ring->req.tp_retire_blk_tov = 60;
851 ring->req.tp_feature_req_word = TP_FT_REQ_FILL_RXHASH;
852
853 err = setsockopt(fd, SOL_PACKET, PACKET_RX_RING, &ring->req,
854 sizeof(ring->req));
855 if (err < 0) {
856 perror("setsockopt");
857 exit(1);
858 }
859
860 ring->map = mmap(NULL, ring->req.tp_block_size * ring->req.tp_block_nr,
861 PROT_READ | PROT_WRITE, MAP_SHARED | MAP_LOCKED, fd, 0);
862 if (ring->map == MAP_FAILED) {
863 perror("mmap");
864 exit(1);
865 }
866
867 ring->rd = malloc(ring->req.tp_block_nr * sizeof(*ring->rd));
868 assert(ring->rd);
869 for (i = 0; i < ring->req.tp_block_nr; ++i) {
870 ring->rd[i].iov_base = ring->map + (i * ring->req.tp_block_size);
871 ring->rd[i].iov_len = ring->req.tp_block_size;
872 }
873
874 memset(&ll, 0, sizeof(ll));
875 ll.sll_family = PF_PACKET;
876 ll.sll_protocol = htons(ETH_P_ALL);
877 ll.sll_ifindex = if_nametoindex(netdev);
878 ll.sll_hatype = 0;
879 ll.sll_pkttype = 0;
880 ll.sll_halen = 0;
881
882 err = bind(fd, (struct sockaddr *) &ll, sizeof(ll));
883 if (err < 0) {
884 perror("bind");
885 exit(1);
886 }
887
888 return fd;
889 }
890
891 static void display(struct tpacket3_hdr *ppd)
892 {
893 struct ethhdr *eth = (struct ethhdr *) ((uint8_t *) ppd + ppd->tp_mac);
894 struct iphdr *ip = (struct iphdr *) ((uint8_t *) eth + ETH_HLEN);
895
896 if (eth->h_proto == htons(ETH_P_IP)) {
897 struct sockaddr_in ss, sd;
898 char sbuff[NI_MAXHOST], dbuff[NI_MAXHOST];
899
900 memset(&ss, 0, sizeof(ss));
901 ss.sin_family = PF_INET;
902 ss.sin_addr.s_addr = ip->saddr;
903 getnameinfo((struct sockaddr *) &ss, sizeof(ss),
904 sbuff, sizeof(sbuff), NULL, 0, NI_NUMERICHOST);
905
906 memset(&sd, 0, sizeof(sd));
907 sd.sin_family = PF_INET;
908 sd.sin_addr.s_addr = ip->daddr;
909 getnameinfo((struct sockaddr *) &sd, sizeof(sd),
910 dbuff, sizeof(dbuff), NULL, 0, NI_NUMERICHOST);
911
912 printf("%s -> %s, ", sbuff, dbuff);
913 }
914
915 printf("rxhash: 0x%x\n", ppd->hv1.tp_rxhash);
916 }
917
918 static void walk_block(struct block_desc *pbd, const int block_num)
919 {
920 int num_pkts = pbd->h1.num_pkts, i;
921 unsigned long bytes = 0;
922 struct tpacket3_hdr *ppd;
923
924 ppd = (struct tpacket3_hdr *) ((uint8_t *) pbd +
925 pbd->h1.offset_to_first_pkt);
926 for (i = 0; i < num_pkts; ++i) {
927 bytes += ppd->tp_snaplen;
928 display(ppd);
929
930 ppd = (struct tpacket3_hdr *) ((uint8_t *) ppd +
931 ppd->tp_next_offset);
932 }
933
934 packets_total += num_pkts;
935 bytes_total += bytes;
936 }
937
938 static void flush_block(struct block_desc *pbd)
939 {
940 pbd->h1.block_status = TP_STATUS_KERNEL;
941 }
942
943 static void teardown_socket(struct ring *ring, int fd)
944 {
945 munmap(ring->map, ring->req.tp_block_size * ring->req.tp_block_nr);
946 free(ring->rd);
947 close(fd);
948 }
949
950 int main(int argc, char **argp)
951 {
952 int fd, err;
953 socklen_t len;
954 struct ring ring;
955 struct pollfd pfd;
956 unsigned int block_num = 0, blocks = 64;
957 struct block_desc *pbd;
958 struct tpacket_stats_v3 stats;
959
960 if (argc != 2) {
961 fprintf(stderr, "Usage: %s INTERFACE\n", argp[0]);
962 return EXIT_FAILURE;
963 }
964
965 signal(SIGINT, sighandler);
966
967 memset(&ring, 0, sizeof(ring));
968 fd = setup_socket(&ring, argp[argc - 1]);
969 assert(fd > 0);
970
971 memset(&pfd, 0, sizeof(pfd));
972 pfd.fd = fd;
973 pfd.events = POLLIN | POLLERR;
974 pfd.revents = 0;
975
976 while (likely(!sigint)) {
977 pbd = (struct block_desc *) ring.rd[block_num].iov_base;
978
979 if ((pbd->h1.block_status & TP_STATUS_USER) == 0) {
980 poll(&pfd, 1, -1);
981 continue;
982 }
983
984 walk_block(pbd, block_num);
985 flush_block(pbd);
986 block_num = (block_num + 1) % blocks;
987 }
988
989 len = sizeof(stats);
990 err = getsockopt(fd, SOL_PACKET, PACKET_STATISTICS, &stats, &len);
991 if (err < 0) {
992 perror("getsockopt");
993 exit(1);
994 }
995
996 fflush(stdout);
997 printf("\nReceived %u packets, %lu bytes, %u dropped, freeze_q_cnt: %u\n",
998 stats.tp_packets, bytes_total, stats.tp_drops,
999 stats.tp_freeze_q_cnt);
1000
1001 teardown_socket(&ring, fd);
1002 return 0;
1003 }
1004
1005PACKET_QDISC_BYPASS
1006===================
1007
1008If there is a requirement to load the network with many packets in a similar
1009fashion as pktgen does, you might set the following option after socket
1010creation::
1011
1012 int one = 1;
1013 setsockopt(fd, SOL_PACKET, PACKET_QDISC_BYPASS, &one, sizeof(one));
1014
1015This has the side-effect, that packets sent through PF_PACKET will bypass the
1016kernel's qdisc layer and are forcedly pushed to the driver directly. Meaning,
1017packet are not buffered, tc disciplines are ignored, increased loss can occur
1018and such packets are also not visible to other PF_PACKET sockets anymore. So,
1019you have been warned; generally, this can be useful for stress testing various
1020components of a system.
1021
1022On default, PACKET_QDISC_BYPASS is disabled and needs to be explicitly enabled
1023on PF_PACKET sockets.
1024
1025PACKET_TIMESTAMP
1026================
1027
1028The PACKET_TIMESTAMP setting determines the source of the timestamp in
1029the packet meta information for mmap(2)ed RX_RING and TX_RINGs. If your
1030NIC is capable of timestamping packets in hardware, you can request those
1031hardware timestamps to be used. Note: you may need to enable the generation
1032of hardware timestamps with SIOCSHWTSTAMP (see related information from
1033Documentation/networking/timestamping.rst).
1034
1035PACKET_TIMESTAMP accepts the same integer bit field as SO_TIMESTAMPING::
1036
1037 int req = SOF_TIMESTAMPING_RAW_HARDWARE;
1038 setsockopt(fd, SOL_PACKET, PACKET_TIMESTAMP, (void *) &req, sizeof(req))
1039
1040For the mmap(2)ed ring buffers, such timestamps are stored in the
1041``tpacket{,2,3}_hdr`` structure's tp_sec and ``tp_{n,u}sec`` members.
1042To determine what kind of timestamp has been reported, the tp_status field
1043is binary or'ed with the following possible bits ...
1044
1045::
1046
1047 TP_STATUS_TS_RAW_HARDWARE
1048 TP_STATUS_TS_SOFTWARE
1049
1050... that are equivalent to its ``SOF_TIMESTAMPING_*`` counterparts. For the
1051RX_RING, if neither is set (i.e. PACKET_TIMESTAMP is not set), then a
1052software fallback was invoked *within* PF_PACKET's processing code (less
1053precise).
1054
1055Getting timestamps for the TX_RING works as follows: i) fill the ring frames,
1056ii) call sendto() e.g. in blocking mode, iii) wait for status of relevant
1057frames to be updated resp. the frame handed over to the application, iv) walk
1058through the frames to pick up the individual hw/sw timestamps.
1059
1060Only (!) if transmit timestamping is enabled, then these bits are combined
1061with binary | with TP_STATUS_AVAILABLE, so you must check for that in your
1062application (e.g. !(tp_status & (TP_STATUS_SEND_REQUEST | TP_STATUS_SENDING))
1063in a first step to see if the frame belongs to the application, and then
1064one can extract the type of timestamp in a second step from tp_status)!
1065
1066If you don't care about them, thus having it disabled, checking for
1067TP_STATUS_AVAILABLE resp. TP_STATUS_WRONG_FORMAT is sufficient. If in the
1068TX_RING part only TP_STATUS_AVAILABLE is set, then the tp_sec and tp_{n,u}sec
1069members do not contain a valid value. For TX_RINGs, by default no timestamp
1070is generated!
1071
1072See include/linux/net_tstamp.h and Documentation/networking/timestamping.rst
1073for more information on hardware timestamps.
1074
1075Miscellaneous bits
1076==================
1077
1078- Packet sockets work well together with Linux socket filters, thus you also
1079 might want to have a look at Documentation/networking/filter.rst
1080
1081THANKS
1082======
1083
1084 Jesse Brandeburg, for fixing my grammathical/spelling errors
1.. SPDX-License-Identifier: GPL-2.0
2
3===========
4Packet MMAP
5===========
6
7Abstract
8========
9
10This file documents the mmap() facility available with the PACKET
11socket interface. This type of sockets is used for
12
13i) capture network traffic with utilities like tcpdump,
14ii) transmit network traffic, or any other that needs raw
15 access to network interface.
16
17Howto can be found at:
18
19 https://sites.google.com/site/packetmmap/
20
21Please send your comments to
22 - Ulisses Alonso Camaró <uaca@i.hate.spam.alumni.uv.es>
23 - Johann Baudy
24
25Why use PACKET_MMAP
26===================
27
28Non PACKET_MMAP capture process (plain AF_PACKET) is very
29inefficient. It uses very limited buffers and requires one system call to
30capture each packet, it requires two if you want to get packet's timestamp
31(like libpcap always does).
32
33On the other hand PACKET_MMAP is very efficient. PACKET_MMAP provides a size
34configurable circular buffer mapped in user space that can be used to either
35send or receive packets. This way reading packets just needs to wait for them,
36most of the time there is no need to issue a single system call. Concerning
37transmission, multiple packets can be sent through one system call to get the
38highest bandwidth. By using a shared buffer between the kernel and the user
39also has the benefit of minimizing packet copies.
40
41It's fine to use PACKET_MMAP to improve the performance of the capture and
42transmission process, but it isn't everything. At least, if you are capturing
43at high speeds (this is relative to the cpu speed), you should check if the
44device driver of your network interface card supports some sort of interrupt
45load mitigation or (even better) if it supports NAPI, also make sure it is
46enabled. For transmission, check the MTU (Maximum Transmission Unit) used and
47supported by devices of your network. CPU IRQ pinning of your network interface
48card can also be an advantage.
49
50How to use mmap() to improve capture process
51============================================
52
53From the user standpoint, you should use the higher level libpcap library, which
54is a de facto standard, portable across nearly all operating systems
55including Win32.
56
57Packet MMAP support was integrated into libpcap around the time of version 1.3.0;
58TPACKET_V3 support was added in version 1.5.0
59
60How to use mmap() directly to improve capture process
61=====================================================
62
63From the system calls stand point, the use of PACKET_MMAP involves
64the following process::
65
66
67 [setup] socket() -------> creation of the capture socket
68 setsockopt() ---> allocation of the circular buffer (ring)
69 option: PACKET_RX_RING
70 mmap() ---------> mapping of the allocated buffer to the
71 user process
72
73 [capture] poll() ---------> to wait for incoming packets
74
75 [shutdown] close() --------> destruction of the capture socket and
76 deallocation of all associated
77 resources.
78
79
80socket creation and destruction is straight forward, and is done
81the same way with or without PACKET_MMAP::
82
83 int fd = socket(PF_PACKET, mode, htons(ETH_P_ALL));
84
85where mode is SOCK_RAW for the raw interface were link level
86information can be captured or SOCK_DGRAM for the cooked
87interface where link level information capture is not
88supported and a link level pseudo-header is provided
89by the kernel.
90
91The destruction of the socket and all associated resources
92is done by a simple call to close(fd).
93
94Similarly as without PACKET_MMAP, it is possible to use one socket
95for capture and transmission. This can be done by mapping the
96allocated RX and TX buffer ring with a single mmap() call.
97See "Mapping and use of the circular buffer (ring)".
98
99Next I will describe PACKET_MMAP settings and its constraints,
100also the mapping of the circular buffer in the user process and
101the use of this buffer.
102
103How to use mmap() directly to improve transmission process
104==========================================================
105Transmission process is similar to capture as shown below::
106
107 [setup] socket() -------> creation of the transmission socket
108 setsockopt() ---> allocation of the circular buffer (ring)
109 option: PACKET_TX_RING
110 bind() ---------> bind transmission socket with a network interface
111 mmap() ---------> mapping of the allocated buffer to the
112 user process
113
114 [transmission] poll() ---------> wait for free packets (optional)
115 send() ---------> send all packets that are set as ready in
116 the ring
117 The flag MSG_DONTWAIT can be used to return
118 before end of transfer.
119
120 [shutdown] close() --------> destruction of the transmission socket and
121 deallocation of all associated resources.
122
123Socket creation and destruction is also straight forward, and is done
124the same way as in capturing described in the previous paragraph::
125
126 int fd = socket(PF_PACKET, mode, 0);
127
128The protocol can optionally be 0 in case we only want to transmit
129via this socket, which avoids an expensive call to packet_rcv().
130In this case, you also need to bind(2) the TX_RING with sll_protocol = 0
131set. Otherwise, htons(ETH_P_ALL) or any other protocol, for example.
132
133Binding the socket to your network interface is mandatory (with zero copy) to
134know the header size of frames used in the circular buffer.
135
136As capture, each frame contains two parts::
137
138 --------------------
139 | struct tpacket_hdr | Header. It contains the status of
140 | | of this frame
141 |--------------------|
142 | data buffer |
143 . . Data that will be sent over the network interface.
144 . .
145 --------------------
146
147 bind() associates the socket to your network interface thanks to
148 sll_ifindex parameter of struct sockaddr_ll.
149
150 Initialization example::
151
152 struct sockaddr_ll my_addr;
153 struct ifreq s_ifr;
154 ...
155
156 strscpy_pad (s_ifr.ifr_name, "eth0", sizeof(s_ifr.ifr_name));
157
158 /* get interface index of eth0 */
159 ioctl(this->socket, SIOCGIFINDEX, &s_ifr);
160
161 /* fill sockaddr_ll struct to prepare binding */
162 my_addr.sll_family = AF_PACKET;
163 my_addr.sll_protocol = htons(ETH_P_ALL);
164 my_addr.sll_ifindex = s_ifr.ifr_ifindex;
165
166 /* bind socket to eth0 */
167 bind(this->socket, (struct sockaddr *)&my_addr, sizeof(struct sockaddr_ll));
168
169 A complete tutorial is available at: https://sites.google.com/site/packetmmap/
170
171By default, the user should put data at::
172
173 frame base + TPACKET_HDRLEN - sizeof(struct sockaddr_ll)
174
175So, whatever you choose for the socket mode (SOCK_DGRAM or SOCK_RAW),
176the beginning of the user data will be at::
177
178 frame base + TPACKET_ALIGN(sizeof(struct tpacket_hdr))
179
180If you wish to put user data at a custom offset from the beginning of
181the frame (for payload alignment with SOCK_RAW mode for instance) you
182can set tp_net (with SOCK_DGRAM) or tp_mac (with SOCK_RAW). In order
183to make this work it must be enabled previously with setsockopt()
184and the PACKET_TX_HAS_OFF option.
185
186PACKET_MMAP settings
187====================
188
189To setup PACKET_MMAP from user level code is done with a call like
190
191 - Capture process::
192
193 setsockopt(fd, SOL_PACKET, PACKET_RX_RING, (void *) &req, sizeof(req))
194
195 - Transmission process::
196
197 setsockopt(fd, SOL_PACKET, PACKET_TX_RING, (void *) &req, sizeof(req))
198
199The most significant argument in the previous call is the req parameter,
200this parameter must to have the following structure::
201
202 struct tpacket_req
203 {
204 unsigned int tp_block_size; /* Minimal size of contiguous block */
205 unsigned int tp_block_nr; /* Number of blocks */
206 unsigned int tp_frame_size; /* Size of frame */
207 unsigned int tp_frame_nr; /* Total number of frames */
208 };
209
210This structure is defined in /usr/include/linux/if_packet.h and establishes a
211circular buffer (ring) of unswappable memory.
212Being mapped in the capture process allows reading the captured frames and
213related meta-information like timestamps without requiring a system call.
214
215Frames are grouped in blocks. Each block is a physically contiguous
216region of memory and holds tp_block_size/tp_frame_size frames. The total number
217of blocks is tp_block_nr. Note that tp_frame_nr is a redundant parameter because::
218
219 frames_per_block = tp_block_size/tp_frame_size
220
221indeed, packet_set_ring checks that the following condition is true::
222
223 frames_per_block * tp_block_nr == tp_frame_nr
224
225Lets see an example, with the following values::
226
227 tp_block_size= 4096
228 tp_frame_size= 2048
229 tp_block_nr = 4
230 tp_frame_nr = 8
231
232we will get the following buffer structure::
233
234 block #1 block #2
235 +---------+---------+ +---------+---------+
236 | frame 1 | frame 2 | | frame 3 | frame 4 |
237 +---------+---------+ +---------+---------+
238
239 block #3 block #4
240 +---------+---------+ +---------+---------+
241 | frame 5 | frame 6 | | frame 7 | frame 8 |
242 +---------+---------+ +---------+---------+
243
244A frame can be of any size with the only condition it can fit in a block. A block
245can only hold an integer number of frames, or in other words, a frame cannot
246be spawned across two blocks, so there are some details you have to take into
247account when choosing the frame_size. See "Mapping and use of the circular
248buffer (ring)".
249
250PACKET_MMAP setting constraints
251===============================
252
253In kernel versions prior to 2.4.26 (for the 2.4 branch) and 2.6.5 (2.6 branch),
254the PACKET_MMAP buffer could hold only 32768 frames in a 32 bit architecture or
25516384 in a 64 bit architecture.
256
257Block size limit
258----------------
259
260As stated earlier, each block is a contiguous physical region of memory. These
261memory regions are allocated with calls to the __get_free_pages() function. As
262the name indicates, this function allocates pages of memory, and the second
263argument is "order" or a power of two number of pages, that is
264(for PAGE_SIZE == 4096) order=0 ==> 4096 bytes, order=1 ==> 8192 bytes,
265order=2 ==> 16384 bytes, etc. The maximum size of a
266region allocated by __get_free_pages is determined by the MAX_PAGE_ORDER macro.
267More precisely the limit can be calculated as::
268
269 PAGE_SIZE << MAX_PAGE_ORDER
270
271 In a i386 architecture PAGE_SIZE is 4096 bytes
272 In a 2.4/i386 kernel MAX_PAGE_ORDER is 10
273 In a 2.6/i386 kernel MAX_PAGE_ORDER is 11
274
275So get_free_pages can allocate as much as 4MB or 8MB in a 2.4/2.6 kernel
276respectively, with an i386 architecture.
277
278User space programs can include /usr/include/sys/user.h and
279/usr/include/linux/mmzone.h to get PAGE_SIZE MAX_PAGE_ORDER declarations.
280
281The pagesize can also be determined dynamically with the getpagesize (2)
282system call.
283
284Block number limit
285------------------
286
287To understand the constraints of PACKET_MMAP, we have to see the structure
288used to hold the pointers to each block.
289
290Currently, this structure is a dynamically allocated vector with kmalloc
291called pg_vec, its size limits the number of blocks that can be allocated::
292
293 +---+---+---+---+
294 | x | x | x | x |
295 +---+---+---+---+
296 | | | |
297 | | | v
298 | | v block #4
299 | v block #3
300 v block #2
301 block #1
302
303kmalloc allocates any number of bytes of physically contiguous memory from
304a pool of pre-determined sizes. This pool of memory is maintained by the slab
305allocator which is at the end the responsible for doing the allocation and
306hence which imposes the maximum memory that kmalloc can allocate.
307
308In a 2.4/2.6 kernel and the i386 architecture, the limit is 131072 bytes. The
309predetermined sizes that kmalloc uses can be checked in the "size-<bytes>"
310entries of /proc/slabinfo
311
312In a 32 bit architecture, pointers are 4 bytes long, so the total number of
313pointers to blocks is::
314
315 131072/4 = 32768 blocks
316
317PACKET_MMAP buffer size calculator
318==================================
319
320Definitions:
321
322============== ================================================================
323<size-max> is the maximum size of allocable with kmalloc
324 (see /proc/slabinfo)
325<pointer size> depends on the architecture -- ``sizeof(void *)``
326<page size> depends on the architecture -- PAGE_SIZE or getpagesize (2)
327<max-order> is the value defined with MAX_PAGE_ORDER
328<frame size> it's an upper bound of frame's capture size (more on this later)
329============== ================================================================
330
331from these definitions we will derive::
332
333 <block number> = <size-max>/<pointer size>
334 <block size> = <pagesize> << <max-order>
335
336so, the max buffer size is::
337
338 <block number> * <block size>
339
340and, the number of frames be::
341
342 <block number> * <block size> / <frame size>
343
344Suppose the following parameters, which apply for 2.6 kernel and an
345i386 architecture::
346
347 <size-max> = 131072 bytes
348 <pointer size> = 4 bytes
349 <pagesize> = 4096 bytes
350 <max-order> = 11
351
352and a value for <frame size> of 2048 bytes. These parameters will yield::
353
354 <block number> = 131072/4 = 32768 blocks
355 <block size> = 4096 << 11 = 8 MiB.
356
357and hence the buffer will have a 262144 MiB size. So it can hold
358262144 MiB / 2048 bytes = 134217728 frames
359
360Actually, this buffer size is not possible with an i386 architecture.
361Remember that the memory is allocated in kernel space, in the case of
362an i386 kernel's memory size is limited to 1GiB.
363
364All memory allocations are not freed until the socket is closed. The memory
365allocations are done with GFP_KERNEL priority, this basically means that
366the allocation can wait and swap other process' memory in order to allocate
367the necessary memory, so normally limits can be reached.
368
369Other constraints
370-----------------
371
372If you check the source code you will see that what I draw here as a frame
373is not only the link level frame. At the beginning of each frame there is a
374header called struct tpacket_hdr used in PACKET_MMAP to hold link level's frame
375meta information like timestamp. So what we draw here a frame it's really
376the following (from include/linux/if_packet.h)::
377
378 /*
379 Frame structure:
380
381 - Start. Frame must be aligned to TPACKET_ALIGNMENT=16
382 - struct tpacket_hdr
383 - pad to TPACKET_ALIGNMENT=16
384 - struct sockaddr_ll
385 - Gap, chosen so that packet data (Start+tp_net) aligns to
386 TPACKET_ALIGNMENT=16
387 - Start+tp_mac: [ Optional MAC header ]
388 - Start+tp_net: Packet data, aligned to TPACKET_ALIGNMENT=16.
389 - Pad to align to TPACKET_ALIGNMENT=16
390 */
391
392The following are conditions that are checked in packet_set_ring
393
394 - tp_block_size must be a multiple of PAGE_SIZE (1)
395 - tp_frame_size must be greater than TPACKET_HDRLEN (obvious)
396 - tp_frame_size must be a multiple of TPACKET_ALIGNMENT
397 - tp_frame_nr must be exactly frames_per_block*tp_block_nr
398
399Note that tp_block_size should be chosen to be a power of two or there will
400be a waste of memory.
401
402Mapping and use of the circular buffer (ring)
403---------------------------------------------
404
405The mapping of the buffer in the user process is done with the conventional
406mmap function. Even the circular buffer is compound of several physically
407discontiguous blocks of memory, they are contiguous to the user space, hence
408just one call to mmap is needed::
409
410 mmap(0, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
411
412If tp_frame_size is a divisor of tp_block_size frames will be
413contiguously spaced by tp_frame_size bytes. If not, each
414tp_block_size/tp_frame_size frames there will be a gap between
415the frames. This is because a frame cannot be spawn across two
416blocks.
417
418To use one socket for capture and transmission, the mapping of both the
419RX and TX buffer ring has to be done with one call to mmap::
420
421 ...
422 setsockopt(fd, SOL_PACKET, PACKET_RX_RING, &foo, sizeof(foo));
423 setsockopt(fd, SOL_PACKET, PACKET_TX_RING, &bar, sizeof(bar));
424 ...
425 rx_ring = mmap(0, size * 2, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
426 tx_ring = rx_ring + size;
427
428RX must be the first as the kernel maps the TX ring memory right
429after the RX one.
430
431At the beginning of each frame there is an status field (see
432struct tpacket_hdr). If this field is 0 means that the frame is ready
433to be used for the kernel, If not, there is a frame the user can read
434and the following flags apply:
435
436Capture process
437^^^^^^^^^^^^^^^
438
439From include/linux/if_packet.h::
440
441 #define TP_STATUS_COPY (1 << 1)
442 #define TP_STATUS_LOSING (1 << 2)
443 #define TP_STATUS_CSUMNOTREADY (1 << 3)
444 #define TP_STATUS_CSUM_VALID (1 << 7)
445
446====================== =======================================================
447TP_STATUS_COPY This flag indicates that the frame (and associated
448 meta information) has been truncated because it's
449 larger than tp_frame_size. This packet can be
450 read entirely with recvfrom().
451
452 In order to make this work it must to be
453 enabled previously with setsockopt() and
454 the PACKET_COPY_THRESH option.
455
456 The number of frames that can be buffered to
457 be read with recvfrom is limited like a normal socket.
458 See the SO_RCVBUF option in the socket (7) man page.
459
460TP_STATUS_LOSING indicates there were packet drops from last time
461 statistics where checked with getsockopt() and
462 the PACKET_STATISTICS option.
463
464TP_STATUS_CSUMNOTREADY currently it's used for outgoing IP packets which
465 its checksum will be done in hardware. So while
466 reading the packet we should not try to check the
467 checksum.
468
469TP_STATUS_CSUM_VALID This flag indicates that at least the transport
470 header checksum of the packet has been already
471 validated on the kernel side. If the flag is not set
472 then we are free to check the checksum by ourselves
473 provided that TP_STATUS_CSUMNOTREADY is also not set.
474====================== =======================================================
475
476for convenience there are also the following defines::
477
478 #define TP_STATUS_KERNEL 0
479 #define TP_STATUS_USER 1
480
481The kernel initializes all frames to TP_STATUS_KERNEL, when the kernel
482receives a packet it puts in the buffer and updates the status with
483at least the TP_STATUS_USER flag. Then the user can read the packet,
484once the packet is read the user must zero the status field, so the kernel
485can use again that frame buffer.
486
487The user can use poll (any other variant should apply too) to check if new
488packets are in the ring::
489
490 struct pollfd pfd;
491
492 pfd.fd = fd;
493 pfd.revents = 0;
494 pfd.events = POLLIN|POLLRDNORM|POLLERR;
495
496 if (status == TP_STATUS_KERNEL)
497 retval = poll(&pfd, 1, timeout);
498
499It doesn't incur in a race condition to first check the status value and
500then poll for frames.
501
502Transmission process
503^^^^^^^^^^^^^^^^^^^^
504
505Those defines are also used for transmission::
506
507 #define TP_STATUS_AVAILABLE 0 // Frame is available
508 #define TP_STATUS_SEND_REQUEST 1 // Frame will be sent on next send()
509 #define TP_STATUS_SENDING 2 // Frame is currently in transmission
510 #define TP_STATUS_WRONG_FORMAT 4 // Frame format is not correct
511
512First, the kernel initializes all frames to TP_STATUS_AVAILABLE. To send a
513packet, the user fills a data buffer of an available frame, sets tp_len to
514current data buffer size and sets its status field to TP_STATUS_SEND_REQUEST.
515This can be done on multiple frames. Once the user is ready to transmit, it
516calls send(). Then all buffers with status equal to TP_STATUS_SEND_REQUEST are
517forwarded to the network device. The kernel updates each status of sent
518frames with TP_STATUS_SENDING until the end of transfer.
519
520At the end of each transfer, buffer status returns to TP_STATUS_AVAILABLE.
521
522::
523
524 header->tp_len = in_i_size;
525 header->tp_status = TP_STATUS_SEND_REQUEST;
526 retval = send(this->socket, NULL, 0, 0);
527
528The user can also use poll() to check if a buffer is available:
529
530(status == TP_STATUS_SENDING)
531
532::
533
534 struct pollfd pfd;
535 pfd.fd = fd;
536 pfd.revents = 0;
537 pfd.events = POLLOUT;
538 retval = poll(&pfd, 1, timeout);
539
540What TPACKET versions are available and when to use them?
541=========================================================
542
543::
544
545 int val = tpacket_version;
546 setsockopt(fd, SOL_PACKET, PACKET_VERSION, &val, sizeof(val));
547 getsockopt(fd, SOL_PACKET, PACKET_VERSION, &val, sizeof(val));
548
549where 'tpacket_version' can be TPACKET_V1 (default), TPACKET_V2, TPACKET_V3.
550
551TPACKET_V1:
552 - Default if not otherwise specified by setsockopt(2)
553 - RX_RING, TX_RING available
554
555TPACKET_V1 --> TPACKET_V2:
556 - Made 64 bit clean due to unsigned long usage in TPACKET_V1
557 structures, thus this also works on 64 bit kernel with 32 bit
558 userspace and the like
559 - Timestamp resolution in nanoseconds instead of microseconds
560 - RX_RING, TX_RING available
561 - VLAN metadata information available for packets
562 (TP_STATUS_VLAN_VALID, TP_STATUS_VLAN_TPID_VALID),
563 in the tpacket2_hdr structure:
564
565 - TP_STATUS_VLAN_VALID bit being set into the tp_status field indicates
566 that the tp_vlan_tci field has valid VLAN TCI value
567 - TP_STATUS_VLAN_TPID_VALID bit being set into the tp_status field
568 indicates that the tp_vlan_tpid field has valid VLAN TPID value
569
570 - How to switch to TPACKET_V2:
571
572 1. Replace struct tpacket_hdr by struct tpacket2_hdr
573 2. Query header len and save
574 3. Set protocol version to 2, set up ring as usual
575 4. For getting the sockaddr_ll,
576 use ``(void *)hdr + TPACKET_ALIGN(hdrlen)`` instead of
577 ``(void *)hdr + TPACKET_ALIGN(sizeof(struct tpacket_hdr))``
578
579TPACKET_V2 --> TPACKET_V3:
580 - Flexible buffer implementation for RX_RING:
581 1. Blocks can be configured with non-static frame-size
582 2. Read/poll is at a block-level (as opposed to packet-level)
583 3. Added poll timeout to avoid indefinite user-space wait
584 on idle links
585 4. Added user-configurable knobs:
586
587 4.1 block::timeout
588 4.2 tpkt_hdr::sk_rxhash
589
590 - RX Hash data available in user space
591 - TX_RING semantics are conceptually similar to TPACKET_V2;
592 use tpacket3_hdr instead of tpacket2_hdr, and TPACKET3_HDRLEN
593 instead of TPACKET2_HDRLEN. In the current implementation,
594 the tp_next_offset field in the tpacket3_hdr MUST be set to
595 zero, indicating that the ring does not hold variable sized frames.
596 Packets with non-zero values of tp_next_offset will be dropped.
597
598AF_PACKET fanout mode
599=====================
600
601In the AF_PACKET fanout mode, packet reception can be load balanced among
602processes. This also works in combination with mmap(2) on packet sockets.
603
604Currently implemented fanout policies are:
605
606 - PACKET_FANOUT_HASH: schedule to socket by skb's packet hash
607 - PACKET_FANOUT_LB: schedule to socket by round-robin
608 - PACKET_FANOUT_CPU: schedule to socket by CPU packet arrives on
609 - PACKET_FANOUT_RND: schedule to socket by random selection
610 - PACKET_FANOUT_ROLLOVER: if one socket is full, rollover to another
611 - PACKET_FANOUT_QM: schedule to socket by skbs recorded queue_mapping
612
613Minimal example code by David S. Miller (try things like "./test eth0 hash",
614"./test eth0 lb", etc.)::
615
616 #include <stddef.h>
617 #include <stdlib.h>
618 #include <stdio.h>
619 #include <string.h>
620
621 #include <sys/types.h>
622 #include <sys/wait.h>
623 #include <sys/socket.h>
624 #include <sys/ioctl.h>
625
626 #include <unistd.h>
627
628 #include <linux/if_ether.h>
629 #include <linux/if_packet.h>
630
631 #include <net/if.h>
632
633 static const char *device_name;
634 static int fanout_type;
635 static int fanout_id;
636
637 #ifndef PACKET_FANOUT
638 # define PACKET_FANOUT 18
639 # define PACKET_FANOUT_HASH 0
640 # define PACKET_FANOUT_LB 1
641 #endif
642
643 static int setup_socket(void)
644 {
645 int err, fd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_IP));
646 struct sockaddr_ll ll;
647 struct ifreq ifr;
648 int fanout_arg;
649
650 if (fd < 0) {
651 perror("socket");
652 return EXIT_FAILURE;
653 }
654
655 memset(&ifr, 0, sizeof(ifr));
656 strcpy(ifr.ifr_name, device_name);
657 err = ioctl(fd, SIOCGIFINDEX, &ifr);
658 if (err < 0) {
659 perror("SIOCGIFINDEX");
660 return EXIT_FAILURE;
661 }
662
663 memset(&ll, 0, sizeof(ll));
664 ll.sll_family = AF_PACKET;
665 ll.sll_ifindex = ifr.ifr_ifindex;
666 err = bind(fd, (struct sockaddr *) &ll, sizeof(ll));
667 if (err < 0) {
668 perror("bind");
669 return EXIT_FAILURE;
670 }
671
672 fanout_arg = (fanout_id | (fanout_type << 16));
673 err = setsockopt(fd, SOL_PACKET, PACKET_FANOUT,
674 &fanout_arg, sizeof(fanout_arg));
675 if (err) {
676 perror("setsockopt");
677 return EXIT_FAILURE;
678 }
679
680 return fd;
681 }
682
683 static void fanout_thread(void)
684 {
685 int fd = setup_socket();
686 int limit = 10000;
687
688 if (fd < 0)
689 exit(fd);
690
691 while (limit-- > 0) {
692 char buf[1600];
693 int err;
694
695 err = read(fd, buf, sizeof(buf));
696 if (err < 0) {
697 perror("read");
698 exit(EXIT_FAILURE);
699 }
700 if ((limit % 10) == 0)
701 fprintf(stdout, "(%d) \n", getpid());
702 }
703
704 fprintf(stdout, "%d: Received 10000 packets\n", getpid());
705
706 close(fd);
707 exit(0);
708 }
709
710 int main(int argc, char **argp)
711 {
712 int fd, err;
713 int i;
714
715 if (argc != 3) {
716 fprintf(stderr, "Usage: %s INTERFACE {hash|lb}\n", argp[0]);
717 return EXIT_FAILURE;
718 }
719
720 if (!strcmp(argp[2], "hash"))
721 fanout_type = PACKET_FANOUT_HASH;
722 else if (!strcmp(argp[2], "lb"))
723 fanout_type = PACKET_FANOUT_LB;
724 else {
725 fprintf(stderr, "Unknown fanout type [%s]\n", argp[2]);
726 exit(EXIT_FAILURE);
727 }
728
729 device_name = argp[1];
730 fanout_id = getpid() & 0xffff;
731
732 for (i = 0; i < 4; i++) {
733 pid_t pid = fork();
734
735 switch (pid) {
736 case 0:
737 fanout_thread();
738
739 case -1:
740 perror("fork");
741 exit(EXIT_FAILURE);
742 }
743 }
744
745 for (i = 0; i < 4; i++) {
746 int status;
747
748 wait(&status);
749 }
750
751 return 0;
752 }
753
754AF_PACKET TPACKET_V3 example
755============================
756
757AF_PACKET's TPACKET_V3 ring buffer can be configured to use non-static frame
758sizes by doing its own memory management. It is based on blocks where polling
759works on a per block basis instead of per ring as in TPACKET_V2 and predecessor.
760
761It is said that TPACKET_V3 brings the following benefits:
762
763 * ~15% - 20% reduction in CPU-usage
764 * ~20% increase in packet capture rate
765 * ~2x increase in packet density
766 * Port aggregation analysis
767 * Non static frame size to capture entire packet payload
768
769So it seems to be a good candidate to be used with packet fanout.
770
771Minimal example code by Daniel Borkmann based on Chetan Loke's lolpcap (compile
772it with gcc -Wall -O2 blob.c, and try things like "./a.out eth0", etc.)::
773
774 /* Written from scratch, but kernel-to-user space API usage
775 * dissected from lolpcap:
776 * Copyright 2011, Chetan Loke <loke.chetan@gmail.com>
777 * License: GPL, version 2.0
778 */
779
780 #include <stdio.h>
781 #include <stdlib.h>
782 #include <stdint.h>
783 #include <string.h>
784 #include <assert.h>
785 #include <net/if.h>
786 #include <arpa/inet.h>
787 #include <netdb.h>
788 #include <poll.h>
789 #include <unistd.h>
790 #include <signal.h>
791 #include <inttypes.h>
792 #include <sys/socket.h>
793 #include <sys/mman.h>
794 #include <linux/if_packet.h>
795 #include <linux/if_ether.h>
796 #include <linux/ip.h>
797
798 #ifndef likely
799 # define likely(x) __builtin_expect(!!(x), 1)
800 #endif
801 #ifndef unlikely
802 # define unlikely(x) __builtin_expect(!!(x), 0)
803 #endif
804
805 struct block_desc {
806 uint32_t version;
807 uint32_t offset_to_priv;
808 struct tpacket_hdr_v1 h1;
809 };
810
811 struct ring {
812 struct iovec *rd;
813 uint8_t *map;
814 struct tpacket_req3 req;
815 };
816
817 static unsigned long packets_total = 0, bytes_total = 0;
818 static sig_atomic_t sigint = 0;
819
820 static void sighandler(int num)
821 {
822 sigint = 1;
823 }
824
825 static int setup_socket(struct ring *ring, char *netdev)
826 {
827 int err, i, fd, v = TPACKET_V3;
828 struct sockaddr_ll ll;
829 unsigned int blocksiz = 1 << 22, framesiz = 1 << 11;
830 unsigned int blocknum = 64;
831
832 fd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
833 if (fd < 0) {
834 perror("socket");
835 exit(1);
836 }
837
838 err = setsockopt(fd, SOL_PACKET, PACKET_VERSION, &v, sizeof(v));
839 if (err < 0) {
840 perror("setsockopt");
841 exit(1);
842 }
843
844 memset(&ring->req, 0, sizeof(ring->req));
845 ring->req.tp_block_size = blocksiz;
846 ring->req.tp_frame_size = framesiz;
847 ring->req.tp_block_nr = blocknum;
848 ring->req.tp_frame_nr = (blocksiz * blocknum) / framesiz;
849 ring->req.tp_retire_blk_tov = 60;
850 ring->req.tp_feature_req_word = TP_FT_REQ_FILL_RXHASH;
851
852 err = setsockopt(fd, SOL_PACKET, PACKET_RX_RING, &ring->req,
853 sizeof(ring->req));
854 if (err < 0) {
855 perror("setsockopt");
856 exit(1);
857 }
858
859 ring->map = mmap(NULL, ring->req.tp_block_size * ring->req.tp_block_nr,
860 PROT_READ | PROT_WRITE, MAP_SHARED | MAP_LOCKED, fd, 0);
861 if (ring->map == MAP_FAILED) {
862 perror("mmap");
863 exit(1);
864 }
865
866 ring->rd = malloc(ring->req.tp_block_nr * sizeof(*ring->rd));
867 assert(ring->rd);
868 for (i = 0; i < ring->req.tp_block_nr; ++i) {
869 ring->rd[i].iov_base = ring->map + (i * ring->req.tp_block_size);
870 ring->rd[i].iov_len = ring->req.tp_block_size;
871 }
872
873 memset(&ll, 0, sizeof(ll));
874 ll.sll_family = PF_PACKET;
875 ll.sll_protocol = htons(ETH_P_ALL);
876 ll.sll_ifindex = if_nametoindex(netdev);
877 ll.sll_hatype = 0;
878 ll.sll_pkttype = 0;
879 ll.sll_halen = 0;
880
881 err = bind(fd, (struct sockaddr *) &ll, sizeof(ll));
882 if (err < 0) {
883 perror("bind");
884 exit(1);
885 }
886
887 return fd;
888 }
889
890 static void display(struct tpacket3_hdr *ppd)
891 {
892 struct ethhdr *eth = (struct ethhdr *) ((uint8_t *) ppd + ppd->tp_mac);
893 struct iphdr *ip = (struct iphdr *) ((uint8_t *) eth + ETH_HLEN);
894
895 if (eth->h_proto == htons(ETH_P_IP)) {
896 struct sockaddr_in ss, sd;
897 char sbuff[NI_MAXHOST], dbuff[NI_MAXHOST];
898
899 memset(&ss, 0, sizeof(ss));
900 ss.sin_family = PF_INET;
901 ss.sin_addr.s_addr = ip->saddr;
902 getnameinfo((struct sockaddr *) &ss, sizeof(ss),
903 sbuff, sizeof(sbuff), NULL, 0, NI_NUMERICHOST);
904
905 memset(&sd, 0, sizeof(sd));
906 sd.sin_family = PF_INET;
907 sd.sin_addr.s_addr = ip->daddr;
908 getnameinfo((struct sockaddr *) &sd, sizeof(sd),
909 dbuff, sizeof(dbuff), NULL, 0, NI_NUMERICHOST);
910
911 printf("%s -> %s, ", sbuff, dbuff);
912 }
913
914 printf("rxhash: 0x%x\n", ppd->hv1.tp_rxhash);
915 }
916
917 static void walk_block(struct block_desc *pbd, const int block_num)
918 {
919 int num_pkts = pbd->h1.num_pkts, i;
920 unsigned long bytes = 0;
921 struct tpacket3_hdr *ppd;
922
923 ppd = (struct tpacket3_hdr *) ((uint8_t *) pbd +
924 pbd->h1.offset_to_first_pkt);
925 for (i = 0; i < num_pkts; ++i) {
926 bytes += ppd->tp_snaplen;
927 display(ppd);
928
929 ppd = (struct tpacket3_hdr *) ((uint8_t *) ppd +
930 ppd->tp_next_offset);
931 }
932
933 packets_total += num_pkts;
934 bytes_total += bytes;
935 }
936
937 static void flush_block(struct block_desc *pbd)
938 {
939 pbd->h1.block_status = TP_STATUS_KERNEL;
940 }
941
942 static void teardown_socket(struct ring *ring, int fd)
943 {
944 munmap(ring->map, ring->req.tp_block_size * ring->req.tp_block_nr);
945 free(ring->rd);
946 close(fd);
947 }
948
949 int main(int argc, char **argp)
950 {
951 int fd, err;
952 socklen_t len;
953 struct ring ring;
954 struct pollfd pfd;
955 unsigned int block_num = 0, blocks = 64;
956 struct block_desc *pbd;
957 struct tpacket_stats_v3 stats;
958
959 if (argc != 2) {
960 fprintf(stderr, "Usage: %s INTERFACE\n", argp[0]);
961 return EXIT_FAILURE;
962 }
963
964 signal(SIGINT, sighandler);
965
966 memset(&ring, 0, sizeof(ring));
967 fd = setup_socket(&ring, argp[argc - 1]);
968 assert(fd > 0);
969
970 memset(&pfd, 0, sizeof(pfd));
971 pfd.fd = fd;
972 pfd.events = POLLIN | POLLERR;
973 pfd.revents = 0;
974
975 while (likely(!sigint)) {
976 pbd = (struct block_desc *) ring.rd[block_num].iov_base;
977
978 if ((pbd->h1.block_status & TP_STATUS_USER) == 0) {
979 poll(&pfd, 1, -1);
980 continue;
981 }
982
983 walk_block(pbd, block_num);
984 flush_block(pbd);
985 block_num = (block_num + 1) % blocks;
986 }
987
988 len = sizeof(stats);
989 err = getsockopt(fd, SOL_PACKET, PACKET_STATISTICS, &stats, &len);
990 if (err < 0) {
991 perror("getsockopt");
992 exit(1);
993 }
994
995 fflush(stdout);
996 printf("\nReceived %u packets, %lu bytes, %u dropped, freeze_q_cnt: %u\n",
997 stats.tp_packets, bytes_total, stats.tp_drops,
998 stats.tp_freeze_q_cnt);
999
1000 teardown_socket(&ring, fd);
1001 return 0;
1002 }
1003
1004PACKET_QDISC_BYPASS
1005===================
1006
1007If there is a requirement to load the network with many packets in a similar
1008fashion as pktgen does, you might set the following option after socket
1009creation::
1010
1011 int one = 1;
1012 setsockopt(fd, SOL_PACKET, PACKET_QDISC_BYPASS, &one, sizeof(one));
1013
1014This has the side-effect, that packets sent through PF_PACKET will bypass the
1015kernel's qdisc layer and are forcedly pushed to the driver directly. Meaning,
1016packet are not buffered, tc disciplines are ignored, increased loss can occur
1017and such packets are also not visible to other PF_PACKET sockets anymore. So,
1018you have been warned; generally, this can be useful for stress testing various
1019components of a system.
1020
1021On default, PACKET_QDISC_BYPASS is disabled and needs to be explicitly enabled
1022on PF_PACKET sockets.
1023
1024PACKET_TIMESTAMP
1025================
1026
1027The PACKET_TIMESTAMP setting determines the source of the timestamp in
1028the packet meta information for mmap(2)ed RX_RING and TX_RINGs. If your
1029NIC is capable of timestamping packets in hardware, you can request those
1030hardware timestamps to be used. Note: you may need to enable the generation
1031of hardware timestamps with SIOCSHWTSTAMP (see related information from
1032Documentation/networking/timestamping.rst).
1033
1034PACKET_TIMESTAMP accepts the same integer bit field as SO_TIMESTAMPING::
1035
1036 int req = SOF_TIMESTAMPING_RAW_HARDWARE;
1037 setsockopt(fd, SOL_PACKET, PACKET_TIMESTAMP, (void *) &req, sizeof(req))
1038
1039For the mmap(2)ed ring buffers, such timestamps are stored in the
1040``tpacket{,2,3}_hdr`` structure's tp_sec and ``tp_{n,u}sec`` members.
1041To determine what kind of timestamp has been reported, the tp_status field
1042is binary or'ed with the following possible bits ...
1043
1044::
1045
1046 TP_STATUS_TS_RAW_HARDWARE
1047 TP_STATUS_TS_SOFTWARE
1048
1049... that are equivalent to its ``SOF_TIMESTAMPING_*`` counterparts. For the
1050RX_RING, if neither is set (i.e. PACKET_TIMESTAMP is not set), then a
1051software fallback was invoked *within* PF_PACKET's processing code (less
1052precise).
1053
1054Getting timestamps for the TX_RING works as follows: i) fill the ring frames,
1055ii) call sendto() e.g. in blocking mode, iii) wait for status of relevant
1056frames to be updated resp. the frame handed over to the application, iv) walk
1057through the frames to pick up the individual hw/sw timestamps.
1058
1059Only (!) if transmit timestamping is enabled, then these bits are combined
1060with binary | with TP_STATUS_AVAILABLE, so you must check for that in your
1061application (e.g. !(tp_status & (TP_STATUS_SEND_REQUEST | TP_STATUS_SENDING))
1062in a first step to see if the frame belongs to the application, and then
1063one can extract the type of timestamp in a second step from tp_status)!
1064
1065If you don't care about them, thus having it disabled, checking for
1066TP_STATUS_AVAILABLE resp. TP_STATUS_WRONG_FORMAT is sufficient. If in the
1067TX_RING part only TP_STATUS_AVAILABLE is set, then the tp_sec and tp_{n,u}sec
1068members do not contain a valid value. For TX_RINGs, by default no timestamp
1069is generated!
1070
1071See include/linux/net_tstamp.h and Documentation/networking/timestamping.rst
1072for more information on hardware timestamps.
1073
1074Miscellaneous bits
1075==================
1076
1077- Packet sockets work well together with Linux socket filters, thus you also
1078 might want to have a look at Documentation/networking/filter.rst
1079
1080THANKS
1081======
1082
1083 Jesse Brandeburg, for fixing my grammathical/spelling errors