docs: networking: convert packet_mmap.txt to ReST

This patch has a big diff, but most are due to whitespaces.

Yet, the conversion is similar to other files under networking:

- add SPDX header;
- add a document title;
- adjust titles and chapters, adding proper markups;
- mark lists as such;
- mark tables as such;
- mark code blocks and literals as such;
- adjust identation, whitespaces and blank lines where needed;
- add to networking/index.rst.
Signed-off-by: Mauro Carvalho Chehab <mchehab+huawei@kernel.org>
Signed-off-by: David S. Miller <davem@davemloft.net>

Documentation/networking/index.rst

@@ -89,6 +89,7 @@ Contents:
    nf_flowtable
    openvswitch
    operstates
+   packet_mmap
 
 .. only::  subproject and html
 

Documentation/networking/packet_mmap.txt → Documentation/networking/packet_mmap.rst

---------------------------------------------------------------------------------
-+ ABSTRACT
---------------------------------------------------------------------------------
+.. SPDX-License-Identifier: GPL-2.0
+
+===========
+Packet MMAP
+===========
+
+Abstract
+========
 
 This file documents the mmap() facility available with the PACKET
 socket interface on 2.4/2.6/3.x kernels. This type of sockets is used for
-i) capture network traffic with utilities like tcpdump, ii) transmit network
-traffic, or any other that needs raw access to network interface.
+
+i) capture network traffic with utilities like tcpdump,
+ii) transmit network traffic, or any other that needs raw
+    access to network interface.
 
 Howto can be found at:
+
     https://sites.google.com/site/packetmmap/
 
 Please send your comments to
-    Ulisses Alonso Camaró <uaca@i.hate.spam.alumni.uv.es>
-    Johann Baudy
+    - Ulisses Alonso Camaró <uaca@i.hate.spam.alumni.uv.es>
+    - Johann Baudy
 
--------------------------------------------------------------------------------
-+ Why use PACKET_MMAP
---------------------------------------------------------------------------------
+Why use PACKET_MMAP
+===================
 
 In Linux 2.4/2.6/3.x if PACKET_MMAP is not enabled, the capture process is very
 inefficient. It uses very limited buffers and requires one system call to
@@ -40,9 +47,8 @@ enabled. For transmission, check the MTU (Maximum Transmission Unit) used and
 supported by devices of your network. CPU IRQ pinning of your network interface
 card can also be an advantage.
 
---------------------------------------------------------------------------------
-+ How to use mmap() to improve capture process
---------------------------------------------------------------------------------
+How to use mmap() to improve capture process
+============================================
 
 From the user standpoint, you should use the higher level libpcap library, which
 is a de facto standard, portable across nearly all operating systems
@@ -51,29 +57,28 @@ including Win32.
 Packet MMAP support was integrated into libpcap around the time of version 1.3.0;
 TPACKET_V3 support was added in version 1.5.0
 
---------------------------------------------------------------------------------
-+ How to use mmap() directly to improve capture process
---------------------------------------------------------------------------------
+How to use mmap() directly to improve capture process
+=====================================================
 
 From the system calls stand point, the use of PACKET_MMAP involves
-the following process:
+the following process::
 
 
-[setup]     socket() -------> creation of the capture socket
+    [setup]     socket() -------> creation of the capture socket
 		setsockopt() ---> allocation of the circular buffer (ring)
 				  option: PACKET_RX_RING
 		mmap() ---------> mapping of the allocated buffer to the
 				  user process
 
-[capture]   poll() ---------> to wait for incoming packets
+    [capture]   poll() ---------> to wait for incoming packets
 
-[shutdown]  close() --------> destruction of the capture socket and
+    [shutdown]  close() --------> destruction of the capture socket and
 				  deallocation of all associated
 				  resources.
 
 
 socket creation and destruction is straight forward, and is done
-the same way with or without PACKET_MMAP:
+the same way with or without PACKET_MMAP::
 
  int fd = socket(PF_PACKET, mode, htons(ETH_P_ALL));
 
@@ -95,29 +100,28 @@ Next I will describe PACKET_MMAP settings and its constraints,
 also the mapping of the circular buffer in the user process and
 the use of this buffer.
 
---------------------------------------------------------------------------------
-+ How to use mmap() directly to improve transmission process
---------------------------------------------------------------------------------
-Transmission process is similar to capture as shown below.
+How to use mmap() directly to improve transmission process
+==========================================================
+Transmission process is similar to capture as shown below::
 
-[setup]          socket() -------> creation of the transmission socket
+    [setup]         socket() -------> creation of the transmission socket
 		    setsockopt() ---> allocation of the circular buffer (ring)
 				      option: PACKET_TX_RING
 		    bind() ---------> bind transmission socket with a network interface
 		    mmap() ---------> mapping of the allocated buffer to the
 				      user process
 
-[transmission]   poll() ---------> wait for free packets (optional)
+    [transmission]  poll() ---------> wait for free packets (optional)
 		    send() ---------> send all packets that are set as ready in
 				      the ring
 				      The flag MSG_DONTWAIT can be used to return
 				      before end of transfer.
 
-[shutdown]  close() --------> destruction of the transmission socket and
+    [shutdown]      close() --------> destruction of the transmission socket and
 				      deallocation of all associated resources.
 
 Socket creation and destruction is also straight forward, and is done
-the same way as in capturing described in the previous paragraph:
+the same way as in capturing described in the previous paragraph::
 
  int fd = socket(PF_PACKET, mode, 0);
 
@@ -129,21 +133,21 @@ set. Otherwise, htons(ETH_P_ALL) or any other protocol, for example.
 Binding the socket to your network interface is mandatory (with zero copy) to
 know the header size of frames used in the circular buffer.
 
-As capture, each frame contains two parts:
+As capture, each frame contains two parts::
 
     --------------------
-| struct tpacket_hdr | Header. It contains the status of
-|                    | of this frame
-|--------------------|
-| data buffer        |
-.                    .  Data that will be sent over the network interface.
-.                    .
+    | struct tpacket_hdr | Header. It contains the status of
+    |                    | of this frame
+    |--------------------|
+    | data buffer        |
+    .                    .  Data that will be sent over the network interface.
+    .                    .
     --------------------
 
  bind() associates the socket to your network interface thanks to
  sll_ifindex parameter of struct sockaddr_ll.
 
- Initialization example:
+ Initialization example::
 
     struct sockaddr_ll my_addr;
     struct ifreq s_ifr;
@@ -164,11 +168,13 @@ As capture, each frame contains two parts:
 
  A complete tutorial is available at: https://sites.google.com/site/packetmmap/
 
-By default, the user should put data at :
+By default, the user should put data at::
+
  frame base + TPACKET_HDRLEN - sizeof(struct sockaddr_ll)
 
 So, whatever you choose for the socket mode (SOCK_DGRAM or SOCK_RAW),
-the beginning of the user data will be at :
+the beginning of the user data will be at::
+
  frame base + TPACKET_ALIGN(sizeof(struct tpacket_hdr))
 
 If you wish to put user data at a custom offset from the beginning of
@@ -177,19 +183,21 @@ can set tp_net (with SOCK_DGRAM) or tp_mac (with SOCK_RAW). In order
 to make this work it must be enabled previously with setsockopt()
 and the PACKET_TX_HAS_OFF option.
 
---------------------------------------------------------------------------------
-+ PACKET_MMAP settings
---------------------------------------------------------------------------------
+PACKET_MMAP settings
+====================
 
 To setup PACKET_MMAP from user level code is done with a call like
 
- - Capture process
+ - Capture process::
+
      setsockopt(fd, SOL_PACKET, PACKET_RX_RING, (void *) &req, sizeof(req))
- - Transmission process
+
+ - Transmission process::
+
      setsockopt(fd, SOL_PACKET, PACKET_TX_RING, (void *) &req, sizeof(req))
 
 The most significant argument in the previous call is the req parameter,
-this parameter must to have the following structure:
+this parameter must to have the following structure::
 
     struct tpacket_req
     {
@@ -206,32 +214,32 @@ related meta-information like timestamps without requiring a system call.
 
 Frames are grouped in blocks. Each block is a physically contiguous
 region of memory and holds tp_block_size/tp_frame_size frames. The total number
-of blocks is tp_block_nr. Note that tp_frame_nr is a redundant parameter because
+of blocks is tp_block_nr. Note that tp_frame_nr is a redundant parameter because::
 
     frames_per_block = tp_block_size/tp_frame_size
 
-indeed, packet_set_ring checks that the following condition is true
+indeed, packet_set_ring checks that the following condition is true::
 
     frames_per_block * tp_block_nr == tp_frame_nr
 
-Lets see an example, with the following values:
+Lets see an example, with the following values::
 
      tp_block_size= 4096
      tp_frame_size= 2048
      tp_block_nr  = 4
      tp_frame_nr  = 8
 
-we will get the following buffer structure:
+we will get the following buffer structure::
 
 	    block #1                 block #2
-+---------+---------+    +---------+---------+    
-| frame 1 | frame 2 |    | frame 3 | frame 4 |    
-+---------+---------+    +---------+---------+    
+    +---------+---------+    +---------+---------+
+    | frame 1 | frame 2 |    | frame 3 | frame 4 |
+    +---------+---------+    +---------+---------+
 
 	    block #3                 block #4
-+---------+---------+    +---------+---------+
-| frame 5 | frame 6 |    | frame 7 | frame 8 |
-+---------+---------+    +---------+---------+
+    +---------+---------+    +---------+---------+
+    | frame 5 | frame 6 |    | frame 7 | frame 8 |
+    +---------+---------+    +---------+---------+
 
 A frame can be of any size with the only condition it can fit in a block. A block
 can only hold an integer number of frames, or in other words, a frame cannot
@@ -239,17 +247,16 @@ be spawned across two blocks, so there are some details you have to take into
 account when choosing the frame_size. See "Mapping and use of the circular
 buffer (ring)".
 
---------------------------------------------------------------------------------
-+ PACKET_MMAP setting constraints
---------------------------------------------------------------------------------
+PACKET_MMAP setting constraints
+===============================
 
 In kernel versions prior to 2.4.26 (for the 2.4 branch) and 2.6.5 (2.6 branch),
 the PACKET_MMAP buffer could hold only 32768 frames in a 32 bit architecture or
 16384 in a 64 bit architecture. For information on these kernel versions
 see http://pusa.uv.es/~ulisses/packet_mmap/packet_mmap.pre-2.4.26_2.6.5.txt
 
- Block size limit
-------------------
+Block size limit
+----------------
 
 As stated earlier, each block is a contiguous physical region of memory. These
 memory regions are allocated with calls to the __get_free_pages() function. As
@@ -258,7 +265,7 @@ argument is "order" or a power of two number of pages, that is
 (for PAGE_SIZE == 4096) order=0 ==> 4096 bytes, order=1 ==> 8192 bytes,
 order=2 ==> 16384 bytes, etc. The maximum size of a
 region allocated by __get_free_pages is determined by the MAX_ORDER macro. More
-precisely the limit can be calculated as:
+precisely the limit can be calculated as::
 
    PAGE_SIZE << MAX_ORDER
 
@@ -275,14 +282,14 @@ User space programs can include /usr/include/sys/user.h and
 The pagesize can also be determined dynamically with the getpagesize (2)
 system call.
 
- Block number limit
---------------------
+Block number limit
+------------------
 
 To understand the constraints of PACKET_MMAP, we have to see the structure
 used to hold the pointers to each block.
 
 Currently, this structure is a dynamically allocated vector with kmalloc
-called pg_vec, its size limits the number of blocks that can be allocated.
+called pg_vec, its size limits the number of blocks that can be allocated::
 
     +---+---+---+---+
     | x | x | x | x |
@@ -304,43 +311,46 @@ predetermined sizes that kmalloc uses can be checked in the "size-<bytes>"
 entries of /proc/slabinfo
 
 In a 32 bit architecture, pointers are 4 bytes long, so the total number of
-pointers to blocks is
+pointers to blocks is::
 
      131072/4 = 32768 blocks
 
- PACKET_MMAP buffer size calculator
-------------------------------------
+PACKET_MMAP buffer size calculator
+==================================
 
 Definitions:
 
-<size-max>    : is the maximum size of allocable with kmalloc (see /proc/slabinfo)
-<pointer size>: depends on the architecture -- sizeof(void *)
-<page size>   : depends on the architecture -- PAGE_SIZE or getpagesize (2)
-<max-order>   : is the value defined with MAX_ORDER
-<frame size>  : it's an upper bound of frame's capture size (more on this later)
+==============  ================================================================
+<size-max>      is the maximum size of allocable with kmalloc
+		(see /proc/slabinfo)
+<pointer size>  depends on the architecture -- ``sizeof(void *)``
+<page size>     depends on the architecture -- PAGE_SIZE or getpagesize (2)
+<max-order>     is the value defined with MAX_ORDER
+<frame size>    it's an upper bound of frame's capture size (more on this later)
+==============  ================================================================
 
-from these definitions we will derive 
+from these definitions we will derive::
 
 	<block number> = <size-max>/<pointer size>
 	<block size> = <pagesize> << <max-order>
 
-so, the max buffer size is
+so, the max buffer size is::
 
 	<block number> * <block size>
 
-and, the number of frames be
+and, the number of frames be::
 
 	<block number> * <block size> / <frame size>
 
 Suppose the following parameters, which apply for 2.6 kernel and an
-i386 architecture:
+i386 architecture::
 
 	<size-max> = 131072 bytes
 	<pointer size> = 4 bytes
 	<pagesize> = 4096 bytes
 	<max-order> = 11
 
-and a value for <frame size> of 2048 bytes. These parameters will yield
+and a value for <frame size> of 2048 bytes. These parameters will yield::
 
 	<block number> = 131072/4 = 32768 blocks
 	<block size> = 4096 << 11 = 8 MiB.
@@ -357,16 +367,16 @@ allocations are done with GFP_KERNEL priority, this basically means that
 the allocation can wait and swap other process' memory in order to allocate
 the necessary memory, so normally limits can be reached.
 
- Other constraints
--------------------
+Other constraints
+-----------------
 
 If you check the source code you will see that what I draw here as a frame
 is not only the link level frame. At the beginning of each frame there is a
 header called struct tpacket_hdr used in PACKET_MMAP to hold link level's frame
 meta information like timestamp. So what we draw here a frame it's really
-the following (from include/linux/if_packet.h):
+the following (from include/linux/if_packet.h)::
 
-/*
+ /*
    Frame structure:
 
    - Start. Frame must be aligned to TPACKET_ALIGNMENT=16
@@ -380,24 +390,23 @@ the following (from include/linux/if_packet.h):
    - Pad to align to TPACKET_ALIGNMENT=16
  */
 
- The following are conditions that are checked in packet_set_ring
+The following are conditions that are checked in packet_set_ring
 
-   tp_block_size must be a multiple of PAGE_SIZE (1)
-   tp_frame_size must be greater than TPACKET_HDRLEN (obvious)
-   tp_frame_size must be a multiple of TPACKET_ALIGNMENT
-   tp_frame_nr   must be exactly frames_per_block*tp_block_nr
+   - tp_block_size must be a multiple of PAGE_SIZE (1)
+   - tp_frame_size must be greater than TPACKET_HDRLEN (obvious)
+   - tp_frame_size must be a multiple of TPACKET_ALIGNMENT
+   - tp_frame_nr   must be exactly frames_per_block*tp_block_nr
 
 Note that tp_block_size should be chosen to be a power of two or there will
 be a waste of memory.
 
---------------------------------------------------------------------------------
-+ Mapping and use of the circular buffer (ring)
---------------------------------------------------------------------------------
+Mapping and use of the circular buffer (ring)
+---------------------------------------------
 
 The mapping of the buffer in the user process is done with the conventional
 mmap function. Even the circular buffer is compound of several physically
 discontiguous blocks of memory, they are contiguous to the user space, hence
-just one call to mmap is needed:
+just one call to mmap is needed::
 
     mmap(0, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
 
@@ -408,7 +417,7 @@ the frames. This is because a frame cannot be spawn across two
 blocks.
 
 To use one socket for capture and transmission, the mapping of both the
-RX and TX buffer ring has to be done with one call to mmap:
+RX and TX buffer ring has to be done with one call to mmap::
 
     ...
     setsockopt(fd, SOL_PACKET, PACKET_RX_RING, &foo, sizeof(foo));
@@ -425,7 +434,9 @@ struct tpacket_hdr). If this field is 0 means that the frame is ready
 to be used for the kernel, If not, there is a frame the user can read
 and the following flags apply:
 
-+++ Capture process:
+Capture process
+^^^^^^^^^^^^^^^
+
      from include/linux/if_packet.h
 
      #define TP_STATUS_COPY          (1 << 1)
@@ -433,7 +444,8 @@ and the following flags apply:
      #define TP_STATUS_CSUMNOTREADY  (1 << 3)
      #define TP_STATUS_CSUM_VALID    (1 << 7)
 
-TP_STATUS_COPY        : This flag indicates that the frame (and associated
+======================  =======================================================
+TP_STATUS_COPY		This flag indicates that the frame (and associated
 			meta information) has been truncated because it's
 			larger than tp_frame_size. This packet can be
 			read entirely with recvfrom().
@@ -446,22 +458,23 @@ TP_STATUS_COPY        : This flag indicates that the frame (and associated
 			be read with recvfrom is limited like a normal socket.
 			See the SO_RCVBUF option in the socket (7) man page.
 
-TP_STATUS_LOSING      : indicates there were packet drops from last time 
+TP_STATUS_LOSING	indicates there were packet drops from last time
 			statistics where checked with getsockopt() and
 			the PACKET_STATISTICS option.
 
-TP_STATUS_CSUMNOTREADY: currently it's used for outgoing IP packets which 
+TP_STATUS_CSUMNOTREADY	currently it's used for outgoing IP packets which
 			its checksum will be done in hardware. So while
 			reading the packet we should not try to check the
 			checksum.
 
-TP_STATUS_CSUM_VALID  : This flag indicates that at least the transport
+TP_STATUS_CSUM_VALID	This flag indicates that at least the transport
 			header checksum of the packet has been already
 			validated on the kernel side. If the flag is not set
 			then we are free to check the checksum by ourselves
 			provided that TP_STATUS_CSUMNOTREADY is also not set.
+======================  =======================================================
 
-for convenience there are also the following defines:
+for convenience there are also the following defines::
 
      #define TP_STATUS_KERNEL        0
      #define TP_STATUS_USER          1
@@ -473,7 +486,7 @@ once the packet is read the user must zero the status field, so the kernel
 can use again that frame buffer.
 
 The user can use poll (any other variant should apply too) to check if new
-packets are in the ring:
+packets are in the ring::
 
     struct pollfd pfd;
 
@@ -487,8 +500,10 @@ packets are in the ring:
 It doesn't incur in a race condition to first check the status value and
 then poll for frames.
 
-++ Transmission process
-Those defines are also used for transmission:
+Transmission process
+^^^^^^^^^^^^^^^^^^^^
+
+Those defines are also used for transmission::
 
      #define TP_STATUS_AVAILABLE        0 // Frame is available
      #define TP_STATUS_SEND_REQUEST     1 // Frame will be sent on next send()
@@ -502,24 +517,31 @@ This can be done on multiple frames. Once the user is ready to transmit, it
 calls send(). Then all buffers with status equal to TP_STATUS_SEND_REQUEST are
 forwarded to the network device. The kernel updates each status of sent
 frames with TP_STATUS_SENDING until the end of transfer.
+
 At the end of each transfer, buffer status returns to TP_STATUS_AVAILABLE.
 
+::
+
     header->tp_len = in_i_size;
     header->tp_status = TP_STATUS_SEND_REQUEST;
     retval = send(this->socket, NULL, 0, 0);
 
 The user can also use poll() to check if a buffer is available:
+
 (status == TP_STATUS_SENDING)
 
+::
+
     struct pollfd pfd;
     pfd.fd = fd;
     pfd.revents = 0;
     pfd.events = POLLOUT;
     retval = poll(&pfd, 1, timeout);
 
--------------------------------------------------------------------------------
-+ What TPACKET versions are available and when to use them?
--------------------------------------------------------------------------------
+What TPACKET versions are available and when to use them?
+=========================================================
+
+::
 
  int val = tpacket_version;
  setsockopt(fd, SOL_PACKET, PACKET_VERSION, &val, sizeof(val));
@@ -540,17 +562,20 @@ TPACKET_V1 --> TPACKET_V2:
 	- VLAN metadata information available for packets
 	  (TP_STATUS_VLAN_VALID, TP_STATUS_VLAN_TPID_VALID),
 	  in the tpacket2_hdr structure:
+
 		- TP_STATUS_VLAN_VALID bit being set into the tp_status field indicates
 		  that the tp_vlan_tci field has valid VLAN TCI value
 		- TP_STATUS_VLAN_TPID_VALID bit being set into the tp_status field
 		  indicates that the tp_vlan_tpid field has valid VLAN TPID value
+
 	- How to switch to TPACKET_V2:
+
 		1. Replace struct tpacket_hdr by struct tpacket2_hdr
 		2. Query header len and save
 		3. Set protocol version to 2, set up ring as usual
 		4. For getting the sockaddr_ll,
-		   use (void *)hdr + TPACKET_ALIGN(hdrlen) instead of
-		   (void *)hdr + TPACKET_ALIGN(sizeof(struct tpacket_hdr))
+		   use ``(void *)hdr + TPACKET_ALIGN(hdrlen)`` instead of
+		   ``(void *)hdr + TPACKET_ALIGN(sizeof(struct tpacket_hdr))``
 
 TPACKET_V2 --> TPACKET_V3:
 	- Flexible buffer implementation for RX_RING:
@@ -559,8 +584,10 @@ TPACKET_V2 --> TPACKET_V3:
 		3. Added poll timeout to avoid indefinite user-space wait
 		   on idle links
 		4. Added user-configurable knobs:
+
 			4.1 block::timeout
 			4.2 tpkt_hdr::sk_rxhash
+
 	- RX Hash data available in user space
 	- TX_RING semantics are conceptually similar to TPACKET_V2;
 	  use tpacket3_hdr instead of tpacket2_hdr, and TPACKET3_HDRLEN
@@ -569,9 +596,8 @@ TPACKET_V2 --> TPACKET_V3:
 	  zero, indicating that the ring does not hold variable sized frames.
 	  Packets with non-zero values of tp_next_offset will be dropped.
 
--------------------------------------------------------------------------------
-+ AF_PACKET fanout mode
--------------------------------------------------------------------------------
+AF_PACKET fanout mode
+=====================
 
 In the AF_PACKET fanout mode, packet reception can be load balanced among
 processes. This also works in combination with mmap(2) on packet sockets.
@@ -586,37 +612,37 @@ Currently implemented fanout policies are:
   - PACKET_FANOUT_QM: schedule to socket by skbs recorded queue_mapping
 
 Minimal example code by David S. Miller (try things like "./test eth0 hash",
-"./test eth0 lb", etc.):
+"./test eth0 lb", etc.)::
 
-#include <stddef.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
+    #include <stddef.h>
+    #include <stdlib.h>
+    #include <stdio.h>
+    #include <string.h>
 
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <sys/socket.h>
-#include <sys/ioctl.h>
+    #include <sys/types.h>
+    #include <sys/wait.h>
+    #include <sys/socket.h>
+    #include <sys/ioctl.h>
 
-#include <unistd.h>
+    #include <unistd.h>
 
-#include <linux/if_ether.h>
-#include <linux/if_packet.h>
+    #include <linux/if_ether.h>
+    #include <linux/if_packet.h>
 
-#include <net/if.h>
+    #include <net/if.h>
 
-static const char *device_name;
-static int fanout_type;
-static int fanout_id;
+    static const char *device_name;
+    static int fanout_type;
+    static int fanout_id;
 
-#ifndef PACKET_FANOUT
-# define PACKET_FANOUT			18
-# define PACKET_FANOUT_HASH		0
-# define PACKET_FANOUT_LB		1
-#endif
+    #ifndef PACKET_FANOUT
+    # define PACKET_FANOUT			18
+    # define PACKET_FANOUT_HASH		0
+    # define PACKET_FANOUT_LB		1
+    #endif
 
-static int setup_socket(void)
-{
+    static int setup_socket(void)
+    {
 	    int err, fd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_IP));
 	    struct sockaddr_ll ll;
 	    struct ifreq ifr;
@@ -653,10 +679,10 @@ static int setup_socket(void)
 	    }
 
 	    return fd;
-}
+    }
 
-static void fanout_thread(void)
-{
+    static void fanout_thread(void)
+    {
 	    int fd = setup_socket();
 	    int limit = 10000;
 
@@ -680,10 +706,10 @@ static void fanout_thread(void)
 
 	    close(fd);
 	    exit(0);
-}
+    }
 
-int main(int argc, char **argp)
-{
+    int main(int argc, char **argp)
+    {
 	    int fd, err;
 	    int i;
 
@@ -724,81 +750,81 @@ int main(int argc, char **argp)
 	    }
 
 	    return 0;
-}
+    }
 
--------------------------------------------------------------------------------
-+ AF_PACKET TPACKET_V3 example
--------------------------------------------------------------------------------
+AF_PACKET TPACKET_V3 example
+============================
 
 AF_PACKET's TPACKET_V3 ring buffer can be configured to use non-static frame
 sizes by doing it's own memory management. It is based on blocks where polling
 works on a per block basis instead of per ring as in TPACKET_V2 and predecessor.
 
 It is said that TPACKET_V3 brings the following benefits:
- *) ~15 - 20% reduction in CPU-usage
- *) ~20% increase in packet capture rate
- *) ~2x increase in packet density
- *) Port aggregation analysis
- *) Non static frame size to capture entire packet payload
+
+ * ~15% - 20% reduction in CPU-usage
+ * ~20% increase in packet capture rate
+ * ~2x increase in packet density
+ * Port aggregation analysis
+ * Non static frame size to capture entire packet payload
 
 So it seems to be a good candidate to be used with packet fanout.
 
 Minimal example code by Daniel Borkmann based on Chetan Loke's lolpcap (compile
-it with gcc -Wall -O2 blob.c, and try things like "./a.out eth0", etc.):
+it with gcc -Wall -O2 blob.c, and try things like "./a.out eth0", etc.)::
 
-/* Written from scratch, but kernel-to-user space API usage
+    /* Written from scratch, but kernel-to-user space API usage
     * dissected from lolpcap:
     *  Copyright 2011, Chetan Loke <loke.chetan@gmail.com>
     *  License: GPL, version 2.0
     */
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <string.h>
-#include <assert.h>
-#include <net/if.h>
-#include <arpa/inet.h>
-#include <netdb.h>
-#include <poll.h>
-#include <unistd.h>
-#include <signal.h>
-#include <inttypes.h>
-#include <sys/socket.h>
-#include <sys/mman.h>
-#include <linux/if_packet.h>
-#include <linux/if_ether.h>
-#include <linux/ip.h>
-
-#ifndef likely
-# define likely(x)		__builtin_expect(!!(x), 1)
-#endif
-#ifndef unlikely
-# define unlikely(x)		__builtin_expect(!!(x), 0)
-#endif
-
-struct block_desc {
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <stdint.h>
+    #include <string.h>
+    #include <assert.h>
+    #include <net/if.h>
+    #include <arpa/inet.h>
+    #include <netdb.h>
+    #include <poll.h>
+    #include <unistd.h>
+    #include <signal.h>
+    #include <inttypes.h>
+    #include <sys/socket.h>
+    #include <sys/mman.h>
+    #include <linux/if_packet.h>
+    #include <linux/if_ether.h>
+    #include <linux/ip.h>
+
+    #ifndef likely
+    # define likely(x)		__builtin_expect(!!(x), 1)
+    #endif
+    #ifndef unlikely
+    # define unlikely(x)		__builtin_expect(!!(x), 0)
+    #endif
+
+    struct block_desc {
 	    uint32_t version;
 	    uint32_t offset_to_priv;
 	    struct tpacket_hdr_v1 h1;
-};
+    };
 
-struct ring {
+    struct ring {
 	    struct iovec *rd;
 	    uint8_t *map;
 	    struct tpacket_req3 req;
-};
+    };
 
-static unsigned long packets_total = 0, bytes_total = 0;
-static sig_atomic_t sigint = 0;
+    static unsigned long packets_total = 0, bytes_total = 0;
+    static sig_atomic_t sigint = 0;
 
-static void sighandler(int num)
-{
+    static void sighandler(int num)
+    {
 	    sigint = 1;
-}
+    }
 
-static int setup_socket(struct ring *ring, char *netdev)
-{
+    static int setup_socket(struct ring *ring, char *netdev)
+    {
 	    int err, i, fd, v = TPACKET_V3;
 	    struct sockaddr_ll ll;
 	    unsigned int blocksiz = 1 << 22, framesiz = 1 << 11;
@@ -860,10 +886,10 @@ static int setup_socket(struct ring *ring, char *netdev)
 	    }
 
 	    return fd;
-}
+    }
 
-static void display(struct tpacket3_hdr *ppd)
-{
+    static void display(struct tpacket3_hdr *ppd)
+    {
 	    struct ethhdr *eth = (struct ethhdr *) ((uint8_t *) ppd + ppd->tp_mac);
 	    struct iphdr *ip = (struct iphdr *) ((uint8_t *) eth + ETH_HLEN);
 
@@ -887,10 +913,10 @@ static void display(struct tpacket3_hdr *ppd)
 	    }
 
 	    printf("rxhash: 0x%x\n", ppd->hv1.tp_rxhash);
-}
+    }
 
-static void walk_block(struct block_desc *pbd, const int block_num)
-{
+    static void walk_block(struct block_desc *pbd, const int block_num)
+    {
 	    int num_pkts = pbd->h1.num_pkts, i;
 	    unsigned long bytes = 0;
 	    struct tpacket3_hdr *ppd;
@@ -907,22 +933,22 @@ static void walk_block(struct block_desc *pbd, const int block_num)
 
 	    packets_total += num_pkts;
 	    bytes_total += bytes;
-}
+    }
 
-static void flush_block(struct block_desc *pbd)
-{
+    static void flush_block(struct block_desc *pbd)
+    {
 	    pbd->h1.block_status = TP_STATUS_KERNEL;
-}
+    }
 
-static void teardown_socket(struct ring *ring, int fd)
-{
+    static void teardown_socket(struct ring *ring, int fd)
+    {
 	    munmap(ring->map, ring->req.tp_block_size * ring->req.tp_block_nr);
 	    free(ring->rd);
 	    close(fd);
-}
+    }
 
-int main(int argc, char **argp)
-{
+    int main(int argc, char **argp)
+    {
 	    int fd, err;
 	    socklen_t len;
 	    struct ring ring;
@@ -974,15 +1000,14 @@ int main(int argc, char **argp)
 
 	    teardown_socket(&ring, fd);
 	    return 0;
-}
+    }
 
--------------------------------------------------------------------------------
-+ PACKET_QDISC_BYPASS
--------------------------------------------------------------------------------
+PACKET_QDISC_BYPASS
+===================
 
 If there is a requirement to load the network with many packets in a similar
 fashion as pktgen does, you might set the following option after socket
-creation:
+creation::
 
     int one = 1;
     setsockopt(fd, SOL_PACKET, PACKET_QDISC_BYPASS, &one, sizeof(one));
@@ -997,9 +1022,8 @@ components of a system.
 On default, PACKET_QDISC_BYPASS is disabled and needs to be explicitly enabled
 on PF_PACKET sockets.
 
--------------------------------------------------------------------------------
-+ PACKET_TIMESTAMP
--------------------------------------------------------------------------------
+PACKET_TIMESTAMP
+================
 
 The PACKET_TIMESTAMP setting determines the source of the timestamp in
 the packet meta information for mmap(2)ed RX_RING and TX_RINGs.  If your
@@ -1008,20 +1032,22 @@ hardware timestamps to be used. Note: you may need to enable the generation
 of hardware timestamps with SIOCSHWTSTAMP (see related information from
 Documentation/networking/timestamping.txt).
 
-PACKET_TIMESTAMP accepts the same integer bit field as SO_TIMESTAMPING:
+PACKET_TIMESTAMP accepts the same integer bit field as SO_TIMESTAMPING::
 
     int req = SOF_TIMESTAMPING_RAW_HARDWARE;
     setsockopt(fd, SOL_PACKET, PACKET_TIMESTAMP, (void *) &req, sizeof(req))
 
 For the mmap(2)ed ring buffers, such timestamps are stored in the
-tpacket{,2,3}_hdr structure's tp_sec and tp_{n,u}sec members. To determine
-what kind of timestamp has been reported, the tp_status field is binary |'ed
-with the following possible bits ...
+``tpacket{,2,3}_hdr`` structure's tp_sec and ``tp_{n,u}sec`` members.
+To determine what kind of timestamp has been reported, the tp_status field
+is binary or'ed with the following possible bits ...
+
+::
 
     TP_STATUS_TS_RAW_HARDWARE
     TP_STATUS_TS_SOFTWARE
 
-... that are equivalent to its SOF_TIMESTAMPING_* counterparts. For the
+... that are equivalent to its ``SOF_TIMESTAMPING_*`` counterparts. For the
 RX_RING, if neither is set (i.e. PACKET_TIMESTAMP is not set), then a
 software fallback was invoked *within* PF_PACKET's processing code (less
 precise).
@@ -1046,16 +1072,13 @@ is generated!
 See include/linux/net_tstamp.h and Documentation/networking/timestamping.txt
 for more information on hardware timestamps.
 
--------------------------------------------------------------------------------
-+ Miscellaneous bits
--------------------------------------------------------------------------------
+Miscellaneous bits
+==================
 
 - Packet sockets work well together with Linux socket filters, thus you also
-  might want to have a look at Documentation/networking/filter.rst
+  might want to have a look at Documentation/networking/filter.txt
 
---------------------------------------------------------------------------------
-+ THANKS
---------------------------------------------------------------------------------
+THANKS
+======
 
    Jesse Brandeburg, for fixing my grammathical/spelling errors
-