Changeset 035f8a7


Ignore:
Timestamp:
02/05/15 15:55:24 (6 years ago)
Author:
Dan Collins <dan@…>
Branches:
4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, libtrace4, master, ndag_format, pfring, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes
Children:
1871afc
Parents:
cb39d35
Message:

Massive refactor that involves moving ring out into its own file.

format_linux is pretty unmaintainable the way it is, so this branch covers
trying to fix that. Ring is basically a subclass of native, so we use OOP
techniques to reduce code duplication. Putting ring in its own file makes
maintaining the code a lot easier as there is less code to read.

The ring format has been spun off, we just need to finish tidying the
native format (stripping out ring, FORMAT(x) turns to FORMAT_DATA etc).
There's bound to be errors in getting it going, but it should be fairly
smooth sailing.

Finally, work was started in moving from the old format design to the
new format design where threaded or not there is a list holding the
per_stream format data.

Location:
lib
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • lib/Makefile.am

    rcb39d35 r035f8a7  
    66
    77extra_DIST = format_template.c
    8 NATIVEFORMATS=format_linux.c
     8NATIVEFORMATS=format_linux_ring.c format_linux.c
    99BPFFORMATS=format_bpf.c
    1010
  • lib/format_linux.c

    r0a1d2d0 r035f8a7  
    5858#else
    5959# error "Can't find inttypes.h"
    60 #endif
     60#endif
     61
     62#include "format_linux.h"
     63
    6164
    6265#ifdef HAVE_NETPACKET_PACKET_H
    63 
    64 #include <sys/socket.h>
    65 #include <netpacket/packet.h>
    66 #include <net/ethernet.h>
    67 #include <net/if_arp.h>
    68 
    69 #include <net/if.h>
    70 #include <sys/ioctl.h>
    71 #include <poll.h>
    72 #include <sys/mman.h>
    73 
    74 #include <fcntl.h>
    75 
    76 /* MAX_ORDER is defined in linux/mmzone.h. 10 is default for 2.4 kernel.
    77  * max_order will be decreased by one if the ring buffer fails to allocate.
    78  * Used to get correct sized buffers from the kernel.
    79  */
    80 #define MAX_ORDER 10
    81 
    82 /* Cached page size, the page size shouldn't be changing */
    83 static int pagesize = 0;
    84 
    85 /* Number of frames in the ring used by both TX and TR rings. More frames
    86  * hopefully means less packet loss, especially if traffic comes in bursts.
    87  */
    88 #define CONF_RING_FRAMES        0x100
    89 
    90 /* The maximum frames allowed to be waiting in the TX_RING before the kernel is
    91  * notified to write them out. Make sure this is less than CONF_RING_FRAMES.
    92  * Performance doesn't seem to increase any more when setting this above 10.
    93  */
    94 #define TX_MAX_QUEUE            10
    95 
    96 /* Get current frame in the ring buffer*/
    97 #define GET_CURRENT_BUFFER(libtrace) ((void *) FORMAT(libtrace->format_data)->rx_ring + \
    98         (FORMAT(libtrace->format_data)->rxring_offset * FORMAT(libtrace->format_data)->req.tp_frame_size))
    99 
    100 
    101 #else   /* HAVE_NETPACKET_PACKET_H */
    102 /* Need to know what a sockaddr_ll looks like */
    103 struct sockaddr_ll {
    104         uint16_t sll_family;
    105         uint16_t sll_protocol;
    106         int32_t  sll_ifindex;
    107         uint16_t sll_hatype;
    108         uint8_t  sll_pkttype;
    109         uint8_t  sll_halen;
    110         uint8_t  sll_addr[8];
    111 };
    112 
    113 /* Packet types.  */
    114 
    115 #define PACKET_HOST             0               /* To us.  */
    116 #define PACKET_BROADCAST        1               /* To all.  */
    117 #define PACKET_MULTICAST        2               /* To group.  */
    118 #define PACKET_OTHERHOST        3               /* To someone else.  */
    119 #define PACKET_OUTGOING         4               /* Originated by us . */
    120 #define PACKET_LOOPBACK         5
    121 #define PACKET_FASTROUTE        6
    122 
    123 /* Packet socket options.  */
    124 
    125 #define PACKET_ADD_MEMBERSHIP           1
    126 #define PACKET_DROP_MEMBERSHIP          2
    127 #define PACKET_RECV_OUTPUT              3
    128 #define PACKET_RX_RING                  5
    129 #define PACKET_STATISTICS               6
    130 
    131 
    132 #endif /* HAVE_NETPACKET_PACKET_H */
    133 
    134 struct tpacket_stats {
    135         unsigned int tp_packets;
    136         unsigned int tp_drops;
    137 };
    138 
    139 typedef enum { TS_NONE, TS_TIMEVAL, TS_TIMESPEC } timestamptype_t;
    140 
    141 /* linux/if_packet.h defines. They are here rather than including the header
    142  * this means that we can interpret a ring frame on a kernel that doesn't
    143  * support the format directly.
    144  */
    145 
    146 
    147 #define PACKET_RX_RING  5
    148 #define PACKET_VERSION  10
    149 #define PACKET_HDRLEN   11
    150 #define PACKET_TX_RING  13
    151 #define PACKET_FANOUT   18
    152 #define TP_STATUS_USER  0x1
    153 #define TP_STATUS_SEND_REQUEST  0x1
    154 #define TP_STATUS_AVAILABLE     0x0
    155 #define TO_TP_HDR(x)    ((struct tpacket2_hdr *) (x))
    156 #define TPACKET_ALIGNMENT       16
    157 #define TPACKET_ALIGN(x)        (((x)+TPACKET_ALIGNMENT-1)&~(TPACKET_ALIGNMENT-1))
    158 #define TPACKET_HDRLEN         (TPACKET_ALIGN(sizeof(struct tpacket2_hdr)) + sizeof(struct sockaddr_ll))
    159 
    160 /* Since 3.1 kernel we have packet_fanout support */
    161 // schedule to socket by skb's rxhash - the implementation is bi-directional
    162 #define PACKET_FANOUT_HASH              0
    163 // schedule round robin
    164 #define PACKET_FANOUT_LB                1
    165 // schedule to the same socket that received the packet
    166 #define PACKET_FANOUT_CPU               2
    167 // Something to do with fragmented packets and hashing problems !! TODO figure out if this needs to be on
    168 #define PACKET_FANOUT_FLAG_DEFRAG       0x8000
    169 /* Included but unused by libtrace since Linux 3.10 */
    170 // if one socket if full roll over to the next
    171 #define PACKET_FANOUT_ROLLOVER          3
    172 // This flag makes any other system roll over
    173 #define PACKET_FANOUT_FLAG_ROLLOVER     0x1000
    174 /* Included but unused by libtrace since Linux 3.12 */
    175 // schedule random
    176 #define PACKET_FANOUT_RND               4
    177 
    178 
    179 enum tpacket_versions {
    180         TPACKET_V1,
    181         TPACKET_V2
    182 };
    183 
    184 struct tpacket2_hdr {
    185         /* Frame status - in use by kernel or libtrace etc. */
    186         uint32_t        tp_status;
    187         /* Wire length */
    188         uint32_t        tp_len;
    189         /* Captured length */
    190         uint32_t        tp_snaplen;
    191         /* Offset in bytes from frame start to the mac (link layer) header */
    192         uint16_t        tp_mac;
    193         /* Offset in bytes from frame start to the net (network layer) header */
    194         uint16_t        tp_net;
    195         /* Timestamp */
    196         uint32_t        tp_sec;
    197         uint32_t        tp_nsec;
    198         /* Not used VLAN tag control information */
    199         uint16_t        tp_vlan_tci;
    200         uint16_t        tp_padding;
    201 };
    202 
    203 struct tpacket_req {
    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 
    210 struct linux_per_thread_t {
    211         char *rx_ring;
    212         int rxring_offset;
    213         int fd;
    214         // The flag layout should be the same for all (I Hope)
    215         // max_order
    216 } ALIGN_STRUCT(CACHE_LINE_SIZE);
    217 
    218 struct linux_format_data_t {
    219         /* The file descriptor being used for the capture */
    220         int fd;
    221         /* The snap length for the capture */
    222         int snaplen;
    223         /* Flag indicating whether the interface should be placed in
    224          * promiscuous mode */
    225         int promisc;
    226         /* The timestamp format used by the capture */
    227         timestamptype_t timestamptype;
    228         /* A BPF filter that is applied to every captured packet */
    229         libtrace_filter_t *filter;
    230         /* Statistics for the capture process, e.g. dropped packet counts */
    231         struct tpacket_stats stats;
    232         /* Flag indicating whether the statistics are current or not */
    233         int stats_valid;
    234         /* The rx ring mmap location*/
    235         char * rx_ring;
    236         /* The current frame number within the rx ring */       
    237         int rxring_offset;
    238         /* The actual format being used - ring vs int */
    239         libtrace_rt_types_t format;
    240         /* The current ring buffer layout */
    241         struct tpacket_req req;
    242         /* Used to determine buffer size for the ring buffer */
    243         uint32_t max_order;
    244         /* Used for the parallel case, fanout is the mode */
    245         uint16_t fanout_flags;
    246         /* The group lets Linux know which sockets to group together
    247          * so we use a random here to try avoid collisions */
    248         uint16_t fanout_group;
    249         /* When running in parallel mode this is malloc'd with an array
    250          * file descriptors from packet fanout will use, here we assume/hope
    251          * that every ring can get setup the same */
    252         struct linux_per_thread_t *per_thread;
    253 };
    254 
    255 
    256 /* Note that this structure is passed over the wire in rt encapsulation, and
    257  * thus we need to be careful with data sizes.  timeval's and timespec's
    258  * can also change their size on 32/64 machines.
    259  */
    260 
    261 /* Format header for encapsulating packets captured using linux native */
    262 struct libtrace_linuxnative_header {
    263         /* Timestamp of the packet, as a timeval */
    264         struct {
    265                 uint32_t tv_sec;
    266                 uint32_t tv_usec;
    267         } tv;
    268         /* Timestamp of the packet, as a timespec */
    269         struct {
    270                 uint32_t tv_sec;
    271                 uint32_t tv_nsec;
    272         } ts;
    273         /* The timestamp format used by the process that captured this packet */
    274         uint8_t timestamptype;
    275         /* Wire length */
    276         uint32_t wirelen;
    277         /* Capture length */
    278         uint32_t caplen;
    279         /* The linux native header itself */
    280         struct sockaddr_ll hdr;
    281 };
    282 
    283 struct linux_output_format_data_t {
    284         /* The file descriptor used to write the packets */
    285         int fd;
    286         /* The tx ring mmap location */
    287         char * tx_ring;
    288         /* The current frame number within the tx ring */       
    289         int txring_offset;
    290         /* The current ring buffer layout */
    291         struct tpacket_req req;
    292         /* Our sockaddr structure, here so we can cache the interface number */
    293         struct sockaddr_ll sock_hdr;
    294         /* The (maximum) number of packets that haven't been written */
    295         int queue;
    296         /* The format this trace is using linuxring or linuxnative */
    297         libtrace_rt_types_t format;
    298         /* Used to determine buffer size for the ring buffer */
    299         uint32_t max_order;
    300 };
    301 
    302 /* Get the sockaddr_ll structure from a frame */
    303 #define GET_SOCKADDR_HDR(x)  ((struct sockaddr_ll *) (((char *) (x))\
    304         + TPACKET_ALIGN(sizeof(struct tpacket2_hdr))))
    305 
    306 #define FORMAT(x) ((struct linux_format_data_t*)(x))
    307 #define PERPKT_FORMAT(x) ((struct linux_per_thread_t*)(x->format_data))
    308 #define DATAOUT(x) ((struct linux_output_format_data_t*)((x)->format_data))
    309 
    310 /* Get the start of the captured data. I'm not sure if tp_mac (link layer) is
    311  * always guaranteed. If it's not there then just use tp_net.
    312  */
    313 #define TP_TRACE_START(mac, net, hdrend) \
    314         ((mac) > (hdrend) && (mac) < (net) ? (mac) : (net))
    315 
    316 
    317 #ifdef HAVE_NETPACKET_PACKET_H
    318 /*
    319  * Try figure out the best sizes for the ring buffer. Ensure that:
    320  * - max(Block_size) == page_size << max_order
    321  * - Frame_size == page_size << x (so that block_size%frame_size == 0)
    322  *   This means that there will be no wasted space between blocks
    323  * - Frame_size < block_size
    324  * - Frame_size is as close as possible to LIBTRACE_PACKET_BUFSIZE, but not
    325  *   bigger
    326  * - Frame_nr = Block_nr * (frames per block)
    327  * - CONF_RING_FRAMES is used a minimum number of frames to hold
    328  * - Calculates based on max_order and buf_min
    329  */
    330 static void calculate_buffers(struct tpacket_req * req, int fd, char * uri,
    331                 uint32_t max_order){
    332        
    333         struct ifreq ifr;
    334         unsigned max_frame = LIBTRACE_PACKET_BUFSIZE;
    335         pagesize = getpagesize();
    336 
    337         strcpy(ifr.ifr_name, uri);
    338         /* Don't bother trying to set frame size above mtu linux will drop
    339          * these anyway.
    340          *
    341          * Remember, that our frame also has to include a TPACKET header!
    342          */
    343         if (ioctl(fd, SIOCGIFMTU, (caddr_t) &ifr) >= 0)
    344                 max_frame = ifr.ifr_mtu + TPACKET_ALIGN(TPACKET_HDRLEN);
    345         if (max_frame > LIBTRACE_PACKET_BUFSIZE)
    346                 max_frame = LIBTRACE_PACKET_BUFSIZE;
    347 
    348         /* Calculate frame size */
    349         req->tp_frame_size = pagesize;
    350         while(req->tp_frame_size < max_frame &&
    351                         req->tp_frame_size < LIBTRACE_PACKET_BUFSIZE){
    352                 req->tp_frame_size <<= 1;
    353         }
    354         if(req->tp_frame_size > LIBTRACE_PACKET_BUFSIZE)
    355                 req->tp_frame_size >>= 1;
    356 
    357         /* Calculate block size */
    358         req->tp_block_size = pagesize << max_order;
    359         do{
    360                 req->tp_block_size >>= 1;
    361         } while((CONF_RING_FRAMES * req->tp_frame_size) <= req->tp_block_size);
    362         req->tp_block_size <<= 1;
    363        
    364         /* Calculate number of blocks */
    365         req->tp_block_nr = (CONF_RING_FRAMES * req->tp_frame_size)
    366                         / req->tp_block_size;
    367         if((CONF_RING_FRAMES * req->tp_frame_size) % req->tp_block_size != 0)
    368                 req->tp_block_nr++;
    369 
    370         /* Calculate packets such that we use all the space we have to allocated */
    371         req->tp_frame_nr = req->tp_block_nr *
    372                         (req->tp_block_size / req->tp_frame_size);
    373 
    374         /*
    375         printf("MaxO 0x%x BS 0x%x BN 0x%x FS 0x%x FN 0x%x\n",
    376                 max_order,
    377                 req->tp_block_size,
    378                 req->tp_block_nr,
    379                 req->tp_frame_size,
    380                 req->tp_frame_nr);
    381         */
    382        
    383         /* In case we have some silly values*/
    384         assert(req->tp_block_size);
    385         assert(req->tp_block_nr);
    386         assert(req->tp_frame_size);
    387         assert(req->tp_frame_nr);
    388         assert(req->tp_block_size % req->tp_frame_size == 0);
    389 }
    390 
    391 
    39266static int linuxnative_probe_filename(const char *filename)
    39367{
     
    39670}
    39771
    398 static inline void init_input(libtrace_t *libtrace){
     72static int linuxnative_init_input(libtrace_t *libtrace)
     73{
     74        struct linux_per_stream_t stream_data;
     75
    39976        libtrace->format_data = (struct linux_format_data_t *)
    40077                malloc(sizeof(struct linux_format_data_t));
    401         FORMAT(libtrace->format_data)->fd = -1;
    402         FORMAT(libtrace->format_data)->promisc = -1;
    403         FORMAT(libtrace->format_data)->snaplen = LIBTRACE_PACKET_BUFSIZE;
    404         FORMAT(libtrace->format_data)->filter = NULL;
    405         FORMAT(libtrace->format_data)->stats_valid = 0;
    406         FORMAT(libtrace->format_data)->rx_ring = NULL;
    407         FORMAT(libtrace->format_data)->rxring_offset = 0;
    408         FORMAT(libtrace->format_data)->max_order = MAX_ORDER;
    409         FORMAT(libtrace->format_data)->fanout_flags = PACKET_FANOUT_LB; // This might be best or alternatively PACKET_FANOUT_LB
    410         // Some examples use pid for the group however that would limit a single
    411         // application to use only int/ring format, instead using rand
    412         FORMAT(libtrace->format_data)->fanout_group = (uint16_t) rand();
    413         FORMAT(libtrace->format_data)->per_thread = NULL;
    414 }
    415 static int linuxring_init_input(libtrace_t *libtrace)
    416 {       
    417         init_input(libtrace);
    418         FORMAT(libtrace->format_data)->format = TRACE_RT_DATA_LINUX_RING;
     78        assert(libtrace->format_data != NULL);
     79
     80        FORMAT_DATA->per_stream =
     81                libtrace_list_init(sizeof(stream_data));
     82        assert(FORMAT_DATA->per_stream != NULL);
     83
     84        /* We'll start with just one instance of stream_data, and we'll
     85         * add more later if we need them */
     86        memset(&stream_data, 0, sizeof(stream_data));
     87        libtrace_list_push_back(FORMAT_DATA->per_stream, &stream_data);
     88
     89        FORMAT_DATA_FIRST->fd = -1;
     90        FORMAT_DATA->promisc = -1;
     91        FORMAT_DATA->snaplen = LIBTRACE_PACKET_BUFSIZE;
     92        FORMAT_DATA->filter = NULL;
     93        FORMAT_DATA->stats_valid = 0;
     94        FORMAT_DATA->fanout_flags = PACKET_FANOUT_LB;
     95        /* Some examples use pid for the group however that would limit a single
     96         * application to use only int/ring format, instead using rand */
     97        FORMAT_DATA->fanout_group = (uint16_t) rand();
     98        FORMAT_DATA->format = TRACE_RT_DATA_LINUX_NATIVE;
     99
    419100        return 0;
    420101}
    421 static int linuxnative_init_input(libtrace_t *libtrace)
    422 {
    423         init_input(libtrace);
    424         FORMAT(libtrace->format_data)->format = TRACE_RT_DATA_LINUX_NATIVE;
    425         return 0;
    426 }
    427 
    428 static inline void init_output(libtrace_out_t *libtrace)
     102
     103static int linuxnative_init_output(libtrace_out_t *libtrace)
    429104{
    430105        libtrace->format_data = (struct linux_output_format_data_t*)
    431106                malloc(sizeof(struct linux_output_format_data_t));
    432         DATAOUT(libtrace)->fd = -1;
    433         DATAOUT(libtrace)->tx_ring = NULL;
    434         DATAOUT(libtrace)->txring_offset = 0;
    435         DATAOUT(libtrace)->queue = 0;
    436         DATAOUT(libtrace)->max_order = MAX_ORDER;
    437 }
    438 static int linuxnative_init_output(libtrace_out_t *libtrace)
    439 {
    440         init_output(libtrace);
    441         DATAOUT(libtrace)->format = TRACE_FORMAT_LINUX_NATIVE;
    442         return 0;
    443 }
    444 static int linuxring_init_output(libtrace_out_t *libtrace)
    445 {
    446         init_output(libtrace);
    447         DATAOUT(libtrace)->format = TRACE_FORMAT_LINUX_RING;
     107        assert(libtrace->format_data != NULL);
     108
     109        FORMAT_DATA_OUT->fd = -1;
     110        FORMAT_DATA_OUT->tx_ring = NULL;
     111        FORMAT_DATA_OUT->txring_offset = 0;
     112        FORMAT_DATA_OUT->queue = 0;
     113        FORMAT_DATA_OUT->max_order = MAX_ORDER;
     114        FORMAT_DATA_OUT->format = TRACE_FORMAT_LINUX_NATIVE;
     115
    448116        return 0;
    449117}
     
    454122        int one = 1;
    455123        memset(&addr,0,sizeof(addr));
    456         libtrace_filter_t *filter = FORMAT(libtrace->format_data)->filter;
    457        
     124        libtrace_filter_t *filter = FORMAT_DATA->filter;
     125
    458126        /* Create a raw socket for reading packets on */
    459         FORMAT(libtrace->format_data)->fd =
    460                                 socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
    461         if (FORMAT(libtrace->format_data)->fd==-1) {
     127        FORMAT_DATA_FIRST->fd =
     128                socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
     129        if (FORMAT_DATA_FIRST->fd==-1) {
    462130                trace_set_err(libtrace, errno, "Could not create raw socket");
    463131                free(libtrace->format_data);
     
    472140                addr.sll_ifindex = if_nametoindex(libtrace->uridata);
    473141                if (addr.sll_ifindex == 0) {
    474                         close(FORMAT(libtrace->format_data)->fd);
    475                         trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Failed to find interface %s", libtrace->uridata);
     142                        close(FORMAT_DATA_FIRST->fd);
     143                        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
     144                                      "Failed to find interface %s",
     145                                      libtrace->uridata);
    476146                        free(libtrace->format_data);
    477147                        libtrace->format_data = NULL;
    478148                        return -1;
    479149                }
    480         }
    481         else {
     150        } else {
    482151                addr.sll_ifindex = 0;
    483152        }
    484         if (bind(FORMAT(libtrace->format_data)->fd,
    485                                 (struct sockaddr*)&addr,
    486                                 (socklen_t)sizeof(addr))==-1) {
     153        if (bind(FORMAT_DATA_FIRST->fd,
     154                 (struct sockaddr*)&addr,
     155                 (socklen_t)sizeof(addr))==-1) {
    487156                free(libtrace->format_data);
    488157                libtrace->format_data = NULL;
    489                 trace_set_err(libtrace, errno, "Failed to bind to interface %s", libtrace->uridata);
     158                trace_set_err(libtrace, errno,
     159                              "Failed to bind to interface %s",
     160                              libtrace->uridata);
    490161                return -1;
    491162        }
    492163
    493         /* If promisc hasn't been specified, set it to "true" if we're 
     164        /* If promisc hasn't been specified, set it to "true" if we're
    494165         * capturing on one interface, or "false" if we're capturing on
    495166         * all interfaces.
    496          */ 
    497         if (FORMAT(libtrace->format_data)->promisc==-1) {
     167         */
     168        if (FORMAT_DATA->promisc==-1) {
    498169                if (addr.sll_ifindex!=0)
    499                         FORMAT(libtrace->format_data)->promisc=1;
     170                        FORMAT_DATA->promisc=1;
    500171                else
    501                         FORMAT(libtrace->format_data)->promisc=0;
    502         }
    503        
    504         /* Enable promiscuous mode, if requested */                     
    505         if (FORMAT(libtrace->format_data)->promisc) {
     172                        FORMAT_DATA->promisc=0;
     173        }
     174
     175        /* Enable promiscuous mode, if requested */
     176        if (FORMAT_DATA->promisc) {
    506177                struct packet_mreq mreq;
    507178                socklen_t socklen = sizeof(mreq);
     
    509180                mreq.mr_ifindex = addr.sll_ifindex;
    510181                mreq.mr_type = PACKET_MR_PROMISC;
    511                 if (setsockopt(FORMAT(libtrace->format_data)->fd,
    512                                 SOL_PACKET,
    513                                 PACKET_ADD_MEMBERSHIP,
    514                                 &mreq,
    515                                 socklen)==-1) {
     182                if (setsockopt(FORMAT_DATA_FIRST->fd,
     183                               SOL_PACKET,
     184                               PACKET_ADD_MEMBERSHIP,
     185                               &mreq,
     186                               socklen)==-1) {
    516187                        perror("setsockopt(PROMISC)");
    517188                }
    518189        }
    519190
    520         /* Set the timestamp option on the socket - aim for the most detailed 
     191        /* Set the timestamp option on the socket - aim for the most detailed
    521192         * clock resolution possible */
    522193#ifdef SO_TIMESTAMPNS
    523         if (setsockopt(FORMAT(libtrace->format_data)->fd,
    524                         SOL_SOCKET,
    525                         SO_TIMESTAMPNS,
    526                         &one,
    527                         (socklen_t)sizeof(one))!=-1) {
    528                 FORMAT(libtrace->format_data)->timestamptype = TS_TIMESPEC;
     194        if (setsockopt(FORMAT_DATA_FIRST->fd,
     195                       SOL_SOCKET,
     196                       SO_TIMESTAMPNS,
     197                       &one,
     198                       (socklen_t)sizeof(one))!=-1) {
     199                FORMAT_DATA->timestamptype = TS_TIMESPEC;
    529200        }
    530201        else
    531         /* DANGER: This is a dangling else to only do the next setsockopt() if we fail the first! */
     202        /* DANGER: This is a dangling else to only do the next setsockopt()
     203         * if we fail the first! */
    532204#endif
    533         if (setsockopt(FORMAT(libtrace->format_data)->fd,
    534                         SOL_SOCKET,
    535                         SO_TIMESTAMP,
    536                         &one,
    537                         (socklen_t)sizeof(one))!=-1) {
    538                 FORMAT(libtrace->format_data)->timestamptype = TS_TIMEVAL;
    539         }
    540         else
    541                 FORMAT(libtrace->format_data)->timestamptype = TS_NONE;
     205                if (setsockopt(FORMAT_DATA_FIRST->fd,
     206                               SOL_SOCKET,
     207                               SO_TIMESTAMP,
     208                               &one,
     209                               (socklen_t)sizeof(one))!=-1) {
     210                        FORMAT_DATA->timestamptype = TS_TIMEVAL;
     211                }
     212                else
     213                        FORMAT_DATA->timestamptype = TS_NONE;
    542214
    543215        /* Push BPF filter into the kernel. At this stage we can safely assume
     
    552224                        return -1;
    553225                }
    554                
    555                 if (setsockopt(FORMAT(libtrace->format_data)->fd,
    556                                         SOL_SOCKET,
    557                                         SO_ATTACH_FILTER,
    558                                         &filter->filter,
    559                                         sizeof(filter->filter)) == -1) {
     226
     227                if (setsockopt(FORMAT_DATA_FIRST->fd,
     228                               SOL_SOCKET,
     229                               SO_ATTACH_FILTER,
     230                               &filter->filter,
     231                               sizeof(filter->filter)) == -1) {
    560232                        perror("setsockopt(SO_ATTACH_FILTER)");
    561                 } else { 
     233                } else {
    562234                        /* The socket accepted the filter, so we need to
    563235                         * consume any buffered packets that were received
     
    565237                         */
    566238                        void *buf = malloc((size_t)LIBTRACE_PACKET_BUFSIZE);
    567                         while(recv(FORMAT(libtrace->format_data)->fd,
    568                                         buf,
    569                                         (size_t) LIBTRACE_PACKET_BUFSIZE,
    570                                         MSG_DONTWAIT) != -1) { }
     239                        while(recv(FORMAT_DATA_FIRST->fd,
     240                                   buf,
     241                                   (size_t)LIBTRACE_PACKET_BUFSIZE,
     242                                   MSG_DONTWAIT) != -1) { }
    571243                        free(buf);
    572244                }
    573245        }
    574246
    575         FORMAT(libtrace->format_data)->stats_valid=0;
    576                                        
     247        FORMAT_DATA->stats_valid = 0;
     248
    577249        return 0;
    578250}
    579 static inline int socket_to_packetmmap( char * uridata, int ring_type,
    580                                         int fd,
    581                                         struct tpacket_req * req,
    582                                         char ** ring_location,
    583                                         uint32_t *max_order,
    584                                         char *error){
    585         int val;
    586 
    587         /* Switch to TPACKET header version 2, we only try support v2 because v1 had problems */
    588 
    589         val = TPACKET_V2;
    590         if (setsockopt(fd,
    591                         SOL_PACKET,
    592                         PACKET_VERSION,
    593                         &val,
    594                         sizeof(val)) == -1){
    595                 strncpy(error, "TPACKET2 not supported", 2048);
    596                 return -1;
    597         }
    598 
    599         /* Try switch to a ring buffer. If it fails we assume the the kernel 
    600          * cannot allocate a block of that size, so decrease max_block and retry.
    601          */
    602         while(1) {     
    603                 if (*max_order <= 0) {
    604                         strncpy(error,"Cannot allocate enough memory for ring buffer", 2048);
    605                         return -1;
    606                 }
    607                 calculate_buffers(req, fd, uridata, *max_order);
    608                 if (setsockopt(fd,
    609                                 SOL_PACKET,
    610                                 ring_type,
    611                                 req,
    612                                 sizeof(struct tpacket_req)) == -1) {
    613                         if(errno == ENOMEM){
    614                                 (*max_order)--;
    615                         } else {
    616                                 strncpy(error, "Error setting the ring buffer size", 2048);
    617                                 return -1;
    618                         }
    619 
    620                 } else break;
    621         }
    622        
    623         /* Map the ring buffer into userspace */
    624         *ring_location = mmap(NULL,
    625                                         req->tp_block_size * req->tp_block_nr,
    626                                         PROT_READ | PROT_WRITE,
    627                                         MAP_SHARED,
    628                                         fd, 0);
    629         if(*ring_location == MAP_FAILED){
    630                 strncpy(error, "Failed to map memory for ring buffer", 2048);
    631                 return -1;
    632         }
    633         return 0;
    634 }
    635251
    636252/**
    637  * Converts a socket, either packet_mmap or standard raw socket into a 
     253 * Converts a socket, either packet_mmap or standard raw socket into a
    638254 * fanout socket.
    639  * NOTE: This means we can read from the socket with multiple queues, 
     255 * NOTE: This means we can read from the socket with multiple queues,
    640256 * each must be setup (identically) and then this called upon them
    641  * 
     257 *
    642258 * @return 0 success, -1 error
    643259 */
    644 static inline int socket_to_packet_fanout(int fd,
    645                                         uint16_t fanout_flags,
    646                                         uint16_t fanout_group) {
     260static inline int socket_to_packet_fanout(int fd,
     261                                          uint16_t fanout_flags,
     262                                          uint16_t fanout_group)
     263{
    647264        int fanout_opt = ((int)fanout_flags << 16) | (int)fanout_group;
    648265        if (setsockopt(fd, SOL_PACKET, PACKET_FANOUT,
     
    650267                return -1;
    651268        }
    652         return 0;
    653 }
    654 
    655 static int linuxnative_ppause_input(libtrace_t *libtrace)
    656 {
    657         int i;
    658         int tot = libtrace->perpkt_thread_count;
    659         printf("CAlling native pause packet\n");
    660        
    661         for (i = 0; i < tot; i++) {
    662                 close(FORMAT(libtrace->format_data)->per_thread[i].fd);
    663         }
    664        
    665         free(FORMAT(libtrace->format_data)->per_thread);
    666         FORMAT(libtrace->format_data)->per_thread = NULL;
    667         return 0;
    668 }
    669 
    670 static int linuxring_start_input(libtrace_t *libtrace)
    671 {
    672         char error[2048];
    673 
    674         /* We set the socket up the same and then convert it to PACKET_MMAP */
    675         if(linuxnative_start_input(libtrace) != 0)
    676                 return -1;
    677 
    678         strncpy(error, "No known error", 2048);
    679 
    680         /* Make it a packetmmap */
    681         if(socket_to_packetmmap(libtrace->uridata, PACKET_RX_RING,
    682                         FORMAT(libtrace->format_data)->fd,
    683                         &FORMAT(libtrace->format_data)->req,
    684                         &FORMAT(libtrace->format_data)->rx_ring,
    685                         &FORMAT(libtrace->format_data)->max_order,
    686                         error) != 0){
    687                 trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "Initialisation of packet MMAP failed: %s", error);
    688                 close(DATAOUT(libtrace)->fd);
    689                 free(libtrace->format_data);
    690                 libtrace->format_data = NULL;
    691                 return -1;
    692         }
    693 
    694269        return 0;
    695270}
     
    781356}
    782357
    783 static int linuxring_start_output(libtrace_out_t *libtrace)
    784 {
    785         char error[2048];       
    786         /* We set the socket up the same and then convert it to PACKET_MMAP */
    787         if(linuxnative_start_output(libtrace) != 0)
    788                 return -1;
    789 
    790         /* Make it a packetmmap */
    791         if(socket_to_packetmmap(libtrace->uridata, PACKET_TX_RING,
    792                         DATAOUT(libtrace)->fd,
    793                         &DATAOUT(libtrace)->req,
    794                         &DATAOUT(libtrace)->tx_ring,
    795                         &DATAOUT(libtrace)->max_order,
    796                         error) != 0){
    797                 trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "Initialisation of packet MMAP failed: %s", error);
    798                 close(DATAOUT(libtrace)->fd);
     358
     359static int linuxnative_pause_input(libtrace_t *libtrace)
     360{
     361        libtrace_list_node_t *tmp = FORMAT_DATA_HEAD;
     362
     363        /* Stop and detach each stream */
     364        while (tmp != NULL) {
     365                close(STREAM_DATA(tmp)->fd);
     366                tmp = tmp->next;
     367        }
     368
     369        return 0;
     370}
     371
     372static int linuxnative_fin_input(libtrace_t *libtrace)
     373{
     374        if (libtrace->format_data) {
     375                if (FORMAT_DATA->filter != NULL)
     376                        free(FORMAT_DATA->filter);
     377
     378                if (FORMAT_DATA->per_stream)
     379                        libtrace_list_deinit(FORMAT_DATA->per_stream);
     380
    799381                free(libtrace->format_data);
    800                 libtrace->format_data = NULL;
    801                 return -1;
    802         }
    803        
    804         DATAOUT(libtrace)->sock_hdr.sll_family = AF_PACKET;
    805         DATAOUT(libtrace)->sock_hdr.sll_protocol = 0;
    806         DATAOUT(libtrace)->sock_hdr.sll_ifindex =
    807                                         if_nametoindex(libtrace->uridata);
    808         DATAOUT(libtrace)->sock_hdr.sll_hatype = 0;
    809         DATAOUT(libtrace)->sock_hdr.sll_pkttype = 0;
    810         DATAOUT(libtrace)->sock_hdr.sll_halen = 0;
    811         DATAOUT(libtrace)->queue = 0;   
    812 
    813         return 0;
    814 }
    815 
    816 static int linuxnative_pause_input(libtrace_t *libtrace)
    817 {
    818         close(FORMAT(libtrace->format_data)->fd);
    819         FORMAT(libtrace->format_data)->fd=-1;
    820 
    821         return 0;
    822 }
    823 
    824 static int linuxring_pause_input(libtrace_t *libtrace)
    825 {
    826         munmap(FORMAT(libtrace->format_data)->rx_ring,
    827                 FORMAT(libtrace->format_data)->req.tp_block_size *
    828                         FORMAT(libtrace->format_data)->req.tp_block_nr);
    829         FORMAT(libtrace->format_data)->rx_ring = NULL;
    830         return linuxnative_pause_input(libtrace);
    831 }
    832 
    833 static int linuxnative_fin_input(libtrace_t *libtrace)
    834 {
    835         if (libtrace->format_data) {
    836                 if (FORMAT(libtrace->format_data)->filter != NULL)
    837                         free(FORMAT(libtrace->format_data)->filter);
    838                 free(libtrace->format_data);
    839         }
    840        
     382        }
     383
    841384        return 0;
    842385}
     
    848391        free(libtrace->format_data);
    849392        return 0;
    850 }
    851 static int linuxring_fin_output(libtrace_out_t *libtrace)
    852 {
    853         /* Make sure any remaining frames get sent */
    854         sendto(DATAOUT(libtrace)->fd,
    855                 NULL,
    856                 0,
    857                 0,
    858                 (void *) &DATAOUT(libtrace)->sock_hdr,
    859                 sizeof(DATAOUT(libtrace)->sock_hdr));
    860 
    861         /* Unmap our data area */
    862         munmap(DATAOUT(libtrace)->tx_ring,
    863                 DATAOUT(libtrace)->req.tp_block_size *
    864                         DATAOUT(libtrace)->req.tp_block_nr);
    865 
    866         return linuxnative_fin_output(libtrace);
    867393}
    868394
     
    1034560}
    1035561
    1036 static int linuxring_prepare_packet(libtrace_t *libtrace UNUSED,
    1037                 libtrace_packet_t *packet, void *buffer,
    1038                 libtrace_rt_types_t rt_type, uint32_t flags) {
    1039 
    1040         if (packet->buffer != buffer &&
    1041                         packet->buf_control == TRACE_CTRL_PACKET) {
    1042                 free(packet->buffer);
    1043         }
    1044 
    1045         if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
    1046                 packet->buf_control = TRACE_CTRL_PACKET;
    1047         } else
    1048                 packet->buf_control = TRACE_CTRL_EXTERNAL;
    1049 
    1050 
    1051         packet->buffer = buffer;
    1052         packet->header = buffer;
    1053         packet->payload = (char *)buffer +
    1054                                         TP_TRACE_START(
    1055                                         TO_TP_HDR(packet->header)->tp_mac,
    1056                                         TO_TP_HDR(packet->header)->tp_net,
    1057                                         TPACKET_HDRLEN);
    1058         packet->type = rt_type;
    1059 
    1060         /*
    1061         if (libtrace->format_data == NULL) {
    1062                 if (linuxnative_init_input(libtrace))
    1063                         return -1;
    1064         }
    1065         */
    1066         return 0;
    1067        
    1068 }
    1069562
    1070563#define LIBTRACE_MIN(a,b) ((a)<(b) ? (a) : (b))
     
    1272765}
    1273766
    1274 #define LIBTRACE_BETWEEN(test,a,b) ((test) >= (a) && (test) < (b))
    1275 static int linuxring_get_capture_length(const libtrace_packet_t *packet);
    1276 static int linuxring_get_framing_length(const libtrace_packet_t *packet);
    1277 
    1278 /* Release a frame back to the kernel or free() if it's a malloc'd buffer
    1279  */
    1280 inline static void ring_release_frame(libtrace_t *libtrace, libtrace_packet_t *packet){
    1281         /* Free the old packet */
    1282         if(packet->buffer == NULL)
    1283                 return;
    1284 
    1285         if(packet->buf_control == TRACE_CTRL_PACKET){
    1286                 free(packet->buffer);
    1287                 packet->buffer = NULL;
    1288         }
    1289         if(packet->buf_control == TRACE_CTRL_EXTERNAL) {
    1290                 struct linux_format_data_t *ftd = FORMAT(libtrace->format_data);
    1291                
    1292                 /* Check it's within our buffer first - consider the pause resume case it might have already been free'd lets hope we get another buffer */
    1293                 // For now let any one free anything
    1294                 /*if(LIBTRACE_BETWEEN((char *) packet->buffer,
    1295                                 (char *) ftd->rx_ring,
    1296                                 ftd->rx_ring
    1297                                 + ftd->req.tp_block_size * ftd->req.tp_block_nr)){*/
    1298                         TO_TP_HDR(packet->buffer)->tp_status = 0;
    1299                         packet->buffer = NULL;
    1300                 /*}*/
    1301         }
    1302 }
    1303 
    1304 /**
    1305  * Free any resources being kept for this packet, Note: libtrace
    1306  * will ensure all fields are zeroed correctly.
    1307  */
    1308 static void linuxring_fin_packet(libtrace_packet_t *packet)
    1309 {
    1310         if (packet->buffer == NULL)
    1311                 return;
    1312         assert(packet->trace);
    1313        
    1314         /* If we own the packet (i.e. it's not a copy), we need to free it */
    1315         if (packet->buf_control == TRACE_CTRL_EXTERNAL) {
    1316                 /* Started should always match the existence of the rx_ring */
    1317                 assert(!!FORMAT(packet->trace->format_data)->rx_ring ==
    1318                        !!packet->trace->started);
    1319                 /* If we don't have a ring its already been destroyed */
    1320                 if (FORMAT(packet->trace->format_data)->rx_ring)
    1321                         ring_release_frame(packet->trace, packet);
    1322                 else
    1323                         packet->buffer = NULL;
    1324         }
    1325 }
    1326 
    1327 inline static int linuxring_read_packet_fd(libtrace_t *libtrace, libtrace_packet_t *packet, int fd, int *rxring_offset, char *rx_ring, int message) {
    1328 
    1329         struct tpacket2_hdr *header;
    1330         int ret;
    1331         unsigned int snaplen;
    1332        
    1333         ring_release_frame(libtrace, packet);
    1334        
    1335         packet->buf_control = TRACE_CTRL_EXTERNAL;
    1336         packet->type = TRACE_RT_DATA_LINUX_RING;
    1337        
    1338         /* Fetch the current frame */
    1339         header = ((void*) rx_ring) + *rxring_offset * FORMAT(libtrace->format_data)->req.tp_frame_size; // GET_CURRENT_BUFFER(libtrace);
    1340         assert((((unsigned long) header) & (pagesize - 1)) == 0);
    1341 
    1342         /* TP_STATUS_USER means that we can use the frame.
    1343          * When a slot does not have this flag set, the frame is not
    1344          * ready for consumption.
    1345          */
    1346         while (!(header->tp_status & TP_STATUS_USER)) {
    1347                 if (message) {
    1348                         struct pollfd pollset[2];
    1349                         pollset[0].fd = fd;
    1350                         pollset[0].events = POLLIN;
    1351                         pollset[0].revents = 0;
    1352                         pollset[1].fd = libtrace_message_queue_get_fd(&get_thread_table(libtrace)->messages);
    1353                         pollset[1].events = POLLIN;
    1354                         pollset[1].revents = 0;
    1355                         /* Wait for more data or a message*/
    1356                         ret = poll(pollset, 2, -1);
    1357                         if (ret < 0) {
    1358                                 if (errno != EINTR)
    1359                                         trace_set_err(libtrace,errno,"poll()");
    1360                                 return -1;
    1361                         }
    1362                         /* A message is ready */
    1363                         if (pollset[1].revents)
    1364                                 return -2;
    1365                 } else {
    1366                         struct pollfd pollset;
    1367                         pollset.fd = fd;
    1368                         pollset.events = POLLIN;
    1369                         pollset.revents = 0;
    1370 
    1371                         /* Wait for more data or a message*/
    1372                         ret = poll(&pollset, 1, 500);
    1373                         if (ret < 0) {
    1374                                 if (errno != EINTR)
    1375                                         trace_set_err(libtrace,errno,"poll()");
    1376                                 return -1;
    1377                         } else if (ret == 0) {
    1378                                 /* Poll timed out - check if we should exit */
    1379                                 if (libtrace_halt)
    1380                                         return 0;
    1381                                 continue;
    1382                         }
    1383                 }
    1384         }
    1385 
    1386         packet->buffer = header;
    1387 
    1388         /* If a snaplen was configured, automatically truncate the packet to
    1389          * the desired length.
    1390          */
    1391         snaplen=LIBTRACE_MIN(
    1392                         (int)LIBTRACE_PACKET_BUFSIZE-(int)sizeof(*header),
    1393                         (int)FORMAT(libtrace->format_data)->snaplen);
    1394        
    1395         TO_TP_HDR(packet->buffer)->tp_snaplen = LIBTRACE_MIN((unsigned int)snaplen, TO_TP_HDR(packet->buffer)->tp_len);
    1396 
    1397         /* Move to next buffer */
    1398         (*rxring_offset)++;
    1399         *rxring_offset %= FORMAT(libtrace->format_data)->req.tp_frame_nr;
    1400 
    1401         /* We just need to get prepare_packet to set all our packet pointers
    1402          * appropriately */
    1403         if (linuxring_prepare_packet(libtrace, packet, packet->buffer,
    1404                                 packet->type, 0))
    1405                 return -1;
    1406         return  linuxring_get_framing_length(packet) +
    1407                                 linuxring_get_capture_length(packet);
    1408 
    1409 }
    1410 
    1411 static int linuxring_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    1412         int fd = FORMAT(libtrace->format_data)->fd;
    1413         int *rxring_offset = &FORMAT(libtrace->format_data)->rxring_offset;
    1414         char *rx_ring = FORMAT(libtrace->format_data)->rx_ring;
    1415         return linuxring_read_packet_fd(libtrace, packet, fd, rxring_offset, rx_ring, 0);
    1416 }
    1417 
    1418 static int linuxring_pread_packets(libtrace_t *libtrace,
    1419                                    libtrace_thread_t *t,
    1420                                    libtrace_packet_t **packets,
    1421                                    UNUSED size_t nb_packets) {
    1422         //fprintf(stderr, "Thread number is #%d\n", t->perpkt_num);
    1423         int fd = PERPKT_FORMAT(t)->fd;
    1424         int *rxring_offset = &PERPKT_FORMAT(t)->rxring_offset;
    1425         char *rx_ring = PERPKT_FORMAT(t)->rx_ring;
    1426         packets[0]->error = linuxring_read_packet_fd(libtrace, packets[0], fd,
    1427                                                      rxring_offset, rx_ring, 1);
    1428         if (packets[0]->error >= 1)
    1429                 return 1;
    1430         else
    1431                 return packets[0]->error;
    1432 }
    1433 
    1434 /* Non-blocking read */
    1435 static libtrace_eventobj_t linuxring_event(libtrace_t *libtrace, libtrace_packet_t *packet) {
    1436         struct tpacket2_hdr *header;
    1437         libtrace_eventobj_t event = {0,0,0.0,0};
    1438 
    1439         /* We must free the old packet, otherwise select() will instantly return
    1440          */
    1441         ring_release_frame(libtrace, packet);
    1442 
    1443         /* Fetch the current frame */
    1444         header = GET_CURRENT_BUFFER(libtrace);
    1445         if(header->tp_status & TP_STATUS_USER){
    1446                 /* We have a frame waiting */
    1447                 event.size = trace_read_packet(libtrace, packet);
    1448                 event.type = TRACE_EVENT_PACKET;
    1449         } else {
    1450                 /* Ok we don't have a packet waiting */
    1451                 event.type = TRACE_EVENT_IOWAIT;
    1452                 event.fd = FORMAT(libtrace->format_data)->fd;
    1453         }
    1454 
    1455         return event;
    1456 }
    1457 
    1458 
    1459767static int linuxnative_write_packet(libtrace_out_t *trace,
    1460768                libtrace_packet_t *packet)
     
    1488796        return ret;
    1489797}
    1490 
    1491 static int linuxring_write_packet(libtrace_out_t *trace,
    1492                 libtrace_packet_t *packet)
    1493 {
    1494         struct tpacket2_hdr *header;
    1495         struct pollfd pollset;
    1496         struct socket_addr;
    1497         int ret;
    1498         unsigned max_size;
    1499         void * off;
    1500 
    1501         if (trace_get_link_type(packet) == TRACE_TYPE_NONDATA)
    1502                 return 0;
    1503 
    1504         max_size = DATAOUT(trace)->req.tp_frame_size -
    1505                  - TPACKET_HDRLEN + sizeof(struct sockaddr_ll);
    1506 
    1507         header = (void *) DATAOUT(trace)->tx_ring +
    1508         (DATAOUT(trace)->txring_offset * DATAOUT(trace)->req.tp_frame_size);
    1509 
    1510         while(header->tp_status != TP_STATUS_AVAILABLE){
    1511                 /* if none available: wait on more data */
    1512                 pollset.fd = DATAOUT(trace)->fd;
    1513                 pollset.events = POLLOUT;
    1514                 pollset.revents = 0;
    1515                 ret = poll(&pollset, 1, 1000);
    1516                 if (ret < 0 && errno != EINTR) {
    1517                         perror("poll");
    1518                         return -1;
    1519                 }
    1520                 if(ret == 0)
    1521                         /* Timeout something has gone wrong - maybe the queue is
    1522                          * to large so try issue another send command
    1523                          */
    1524                         ret = sendto(DATAOUT(trace)->fd,
    1525                                 NULL,
    1526                                 0,
    1527                                 0,
    1528                                 (void *) &DATAOUT(trace)->sock_hdr,
    1529                                 sizeof(DATAOUT(trace)->sock_hdr));
    1530                         if (ret < 0) {
    1531                                 trace_set_err_out(trace, errno,
    1532                                                 "sendto after timeout failed");
    1533                                 return -1;
    1534                         }
    1535         }
    1536        
    1537         header->tp_len = trace_get_capture_length(packet);
    1538 
    1539         /* We cannot write the whole packet so just write part of it */
    1540         if (header->tp_len > max_size)
    1541                 header->tp_len = max_size;
    1542 
    1543         /* Fill packet - no sockaddr_ll in header when writing to the TX_RING */
    1544         off = ((void *) header) + (TPACKET_HDRLEN - sizeof(struct sockaddr_ll));
    1545         memcpy(off,
    1546                 (char *) packet->payload,
    1547                 header->tp_len);
    1548        
    1549         /* 'Send it' and increase ring pointer to the next frame */
    1550         header->tp_status = TP_STATUS_SEND_REQUEST;
    1551         DATAOUT(trace)->txring_offset = (DATAOUT(trace)->txring_offset + 1) % 
    1552                                                 DATAOUT(trace)->req.tp_frame_nr;
    1553 
    1554         /* Notify kernel there are frames to send */
    1555         DATAOUT(trace)->queue ++;
    1556         DATAOUT(trace)->queue %= TX_MAX_QUEUE;
    1557         if(DATAOUT(trace)->queue == 0){
    1558                 ret = sendto(DATAOUT(trace)->fd,
    1559                                 NULL,
    1560                                 0,
    1561                                 MSG_DONTWAIT,
    1562                                 (void *) &DATAOUT(trace)->sock_hdr,
    1563                                 sizeof(DATAOUT(trace)->sock_hdr));
    1564                 if (ret < 0) {
    1565                         trace_set_err_out(trace, errno, "sendto failed");
    1566                         return -1;
    1567                 }
    1568         }
    1569         return header->tp_len;
    1570 
    1571 }
    1572798#endif /* HAVE_NETPACKET_PACKET_H */
    1573799
    1574 static inline libtrace_linktype_t get_libtrace_link_type(uint16_t linktype){
    1575         /* Convert the ARPHRD type into an appropriate libtrace link type */
    1576         switch (linktype) {
    1577                 case LIBTRACE_ARPHRD_ETHER:
    1578                 case LIBTRACE_ARPHRD_LOOPBACK:
    1579                         return TRACE_TYPE_ETH;
    1580                 case LIBTRACE_ARPHRD_PPP:
    1581                         return TRACE_TYPE_NONE;
    1582                 case LIBTRACE_ARPHRD_IEEE80211_RADIOTAP:
    1583                         return TRACE_TYPE_80211_RADIO;
    1584                 case LIBTRACE_ARPHRD_IEEE80211:
    1585                         return TRACE_TYPE_80211;
    1586                 case LIBTRACE_ARPHRD_SIT:
    1587                 case LIBTRACE_ARPHRD_NONE:
    1588                         return TRACE_TYPE_NONE;
    1589                 default: /* shrug, beyond me! */
    1590                         printf("unknown Linux ARPHRD type 0x%04x\n",linktype);
    1591                         return (libtrace_linktype_t)~0U;
    1592         }
    1593 }
     800
    1594801static libtrace_linktype_t linuxnative_get_link_type(const struct libtrace_packet_t *packet) {
    1595802        uint16_t linktype=(((struct libtrace_linuxnative_header*)(packet->buffer))
     
    1597804        return get_libtrace_link_type(linktype);
    1598805}
    1599 static libtrace_linktype_t linuxring_get_link_type(const struct libtrace_packet_t *packet) {
    1600         uint16_t linktype= GET_SOCKADDR_HDR(packet->buffer)->sll_hatype;
    1601         return get_libtrace_link_type(linktype);
    1602 }
    1603 
    1604 static inline libtrace_direction_t get_libtrace_direction(uint8_t pkttype){
    1605         switch (pkttype) {
    1606                 case PACKET_OUTGOING:
    1607                 case PACKET_LOOPBACK:
    1608                         return TRACE_DIR_OUTGOING;
    1609                 case PACKET_OTHERHOST:
    1610                         return TRACE_DIR_OTHER;
    1611                 default:
    1612                         return TRACE_DIR_INCOMING;
    1613         }
    1614 }
     806
    1615807static libtrace_direction_t linuxnative_get_direction(const struct libtrace_packet_t *packet) {
    1616808        return get_libtrace_direction(((struct libtrace_linuxnative_header*)(packet->buffer))->hdr.sll_pkttype);
    1617809}
    1618 static libtrace_direction_t linuxring_get_direction(const struct libtrace_packet_t *packet) {
    1619         return get_libtrace_direction(GET_SOCKADDR_HDR(packet->buffer)->sll_pkttype);
    1620 }
    1621 
    1622 static libtrace_direction_t set_direction(struct sockaddr_ll * skadr, libtrace_direction_t direction){
    1623         switch (direction) {
    1624                 case TRACE_DIR_OUTGOING:
    1625                         skadr->sll_pkttype = PACKET_OUTGOING;
    1626                         return TRACE_DIR_OUTGOING;
    1627                 case TRACE_DIR_INCOMING:
    1628                         skadr->sll_pkttype = PACKET_HOST;
    1629                         return TRACE_DIR_INCOMING;
    1630                 case TRACE_DIR_OTHER:
    1631                         skadr->sll_pkttype = PACKET_OTHERHOST;
    1632                         return TRACE_DIR_OTHER;
    1633                 default:
    1634                         return -1;
    1635         }
    1636 }
     810
    1637811static libtrace_direction_t linuxnative_set_direction(
    1638812                libtrace_packet_t *packet,
    1639813                libtrace_direction_t direction) {
    1640814        return set_direction(&((struct libtrace_linuxnative_header*)(packet->buffer))->hdr, direction);
    1641 }
    1642 static libtrace_direction_t linuxring_set_direction(
    1643                 libtrace_packet_t *packet,
    1644                 libtrace_direction_t direction) {
    1645         return set_direction(GET_SOCKADDR_HDR(packet->buffer), direction);
    1646815}
    1647816
     
    1664833        }
    1665834}
    1666 static struct timespec linuxring_get_timespec(const libtrace_packet_t *packet)
    1667 {
    1668         struct timespec ts;
    1669         ts.tv_sec = TO_TP_HDR(packet->buffer)->tp_sec;
    1670         ts.tv_nsec = TO_TP_HDR(packet->buffer)->tp_nsec;
    1671         return ts;
    1672 }
    1673 
    1674835
    1675836static struct timeval linuxnative_get_timeval(const libtrace_packet_t *packet)
     
    1691852        }
    1692853}
    1693 static struct timeval linuxring_get_timeval(const libtrace_packet_t *packet)
    1694 {
    1695         struct timeval tv;
    1696         tv.tv_sec = TO_TP_HDR(packet->buffer)->tp_sec;
    1697         tv.tv_usec = TO_TP_HDR(packet->buffer)->tp_nsec / 1000;
    1698         return tv;
    1699 }
    1700854
    1701855static int linuxnative_get_capture_length(const libtrace_packet_t *packet)
     
    1704858}
    1705859
    1706 static int linuxring_get_capture_length(const libtrace_packet_t *packet)
    1707 {
    1708         return TO_TP_HDR(packet->buffer)->tp_snaplen;
    1709 }
    1710860
    1711861static int linuxnative_get_wire_length(const libtrace_packet_t *packet)
     
    1721871}
    1722872
    1723 static int linuxring_get_wire_length(const libtrace_packet_t *packet)
    1724 {
    1725         int wirelen = TO_TP_HDR(packet->buffer)->tp_len;
    1726 
    1727         /* Include the missing FCS */
    1728         if (trace_get_link_type(packet) == TRACE_TYPE_ETH)
    1729                 wirelen += 4;
    1730 
    1731         return wirelen;
    1732 }
    1733873
    1734874static int linuxnative_get_framing_length(UNUSED
     
    1736876{
    1737877        return sizeof(struct libtrace_linuxnative_header);
    1738 }
    1739 
    1740 static int linuxring_get_framing_length(const libtrace_packet_t *packet)
    1741 {       
    1742         /*
    1743          * Need to make frame_length + capture_length = complete capture length
    1744          * so include alligment whitespace. So reverse calculate from packet.
    1745          */
    1746         return (char *) packet->payload - (char *) packet->buffer;
    1747878}
    1748879
     
    1762893        linux_hdr = (struct libtrace_linuxnative_header *)packet->header;
    1763894        linux_hdr->caplen = size;
    1764         return trace_get_capture_length(packet);
    1765 }
    1766 
    1767 static size_t linuxring_set_capture_length(libtrace_packet_t *packet,
    1768                 size_t size) {
    1769         assert(packet);
    1770         if (size > trace_get_capture_length(packet)) {
    1771                 /* We should avoid making a packet larger */
    1772                 return trace_get_capture_length(packet);
    1773         }
    1774        
    1775         /* Reset the cached capture length */
    1776         packet->capture_length = -1;
    1777 
    1778         TO_TP_HDR(packet->buffer)->tp_snaplen = size;
    1779 
    1780895        return trace_get_capture_length(packet);
    1781896}
     
    19021017        printf("Supported output URIs:\n");
    19031018        printf("\tint:eth0\n");
    1904         printf("\n");
    1905         return;
    1906 }
    1907 
    1908 static void linuxring_help(void) {
    1909         printf("linuxring format module: $Revision: 1793 $\n");
    1910         printf("Supported input URIs:\n");
    1911         printf("\tring:eth0\n");
    1912         printf("\n");
    1913         printf("Supported output URIs:\n");
    1914         printf("\tring:eth0\n");
    19151019        printf("\n");
    19161020        return;
     
    19671071        NULL
    19681072};
    1969 
    1970 static struct libtrace_format_t linuxring = {
    1971         "ring",
    1972         "$Id$",
    1973         TRACE_FORMAT_LINUX_RING,
    1974         linuxnative_probe_filename,     /* probe filename */
    1975         NULL,                           /* probe magic */
    1976         linuxring_init_input,           /* init_input */
    1977         linuxnative_config_input,       /* config_input */
    1978         linuxring_start_input,  /* start_input */
    1979         linuxring_pause_input,  /* pause_input */
    1980         linuxring_init_output,  /* init_output */
    1981         NULL,                           /* config_output */
    1982         linuxring_start_output, /* start_ouput */
    1983         linuxnative_fin_input,          /* fin_input */
    1984         linuxring_fin_output,           /* fin_output */
    1985         linuxring_read_packet,  /* read_packet */
    1986         linuxring_prepare_packet,       /* prepare_packet */
    1987         linuxring_fin_packet,                           /* fin_packet */
    1988         linuxring_write_packet, /* write_packet */
    1989         linuxring_get_link_type,        /* get_link_type */
    1990         linuxring_get_direction,        /* get_direction */
    1991         linuxring_set_direction,        /* set_direction */
    1992         NULL,                           /* get_erf_timestamp */
    1993         linuxring_get_timeval,  /* get_timeval */
    1994         linuxring_get_timespec, /* get_timespec */
    1995         NULL,                           /* get_seconds */
    1996         NULL,                           /* seek_erf */
    1997         NULL,                           /* seek_timeval */
    1998         NULL,                           /* seek_seconds */
    1999         linuxring_get_capture_length,   /* get_capture_length */
    2000         linuxring_get_wire_length,      /* get_wire_length */
    2001         linuxring_get_framing_length,   /* get_framing_length */
    2002         linuxring_set_capture_length,   /* set_capture_length */
    2003         NULL,                           /* get_received_packets */
    2004         linuxnative_get_filtered_packets,/* get_filtered_packets */
    2005         linuxnative_get_dropped_packets,/* get_dropped_packets */
    2006         linuxnative_get_captured_packets,/* get_captured_packets */
    2007         linuxnative_get_fd,             /* get_fd */
    2008         linuxring_event,                /* trace_event */
    2009         linuxring_help,         /* help */
    2010         NULL,                           /* next pointer */
    2011         {true, -1},              /* Live, no thread limit */
    2012         linuxnative_pstart_input,                       /* pstart_input */
    2013         linuxring_pread_packets,                        /* pread_packets */
    2014         linuxnative_ppause_input,                       /* ppause */
    2015         linuxnative_fin_input,                          /* p_fin */
    2016         linuxnative_pconfig_input,
    2017         linux_pregister_thread,
    2018         NULL
    2019 };
    20201073#else
    20211074static void linuxnative_help(void) {
    20221075        printf("linuxnative format module: $Revision: 1793 $\n");
    2023         printf("Not supported on this host\n");
    2024 }
    2025 static void linuxring_help(void) {
    2026         printf("linuxring format module: $Revision: 1793 $\n");
    20271076        printf("Not supported on this host\n");
    20281077}
     
    20711120        NON_PARALLEL(true)
    20721121};
    2073 
    2074 static struct libtrace_format_t linuxring = {
    2075         "ring",
    2076         "$Id$",
    2077         TRACE_FORMAT_LINUX_RING,
    2078         NULL,                           /* probe filename */
    2079         NULL,                           /* probe magic */
    2080         NULL,                           /* init_input */
    2081         NULL,                           /* config_input */
    2082         NULL,                           /* start_input */
    2083         NULL,                           /* pause_input */
    2084         NULL,                           /* init_output */
    2085         NULL,                           /* config_output */
    2086         NULL,                           /* start_ouput */
    2087         NULL,                           /* fin_input */
    2088         NULL,                           /* fin_output */
    2089         NULL,                           /* read_packet */
    2090         linuxring_prepare_packet,       /* prepare_packet */
    2091         NULL,                           /* fin_packet */
    2092         NULL,                           /* write_packet */
    2093         linuxring_get_link_type,        /* get_link_type */
    2094         linuxring_get_direction,        /* get_direction */
    2095         linuxring_set_direction,        /* set_direction */
    2096         NULL,                           /* get_erf_timestamp */
    2097         linuxring_get_timeval,          /* get_timeval */
    2098         linuxring_get_timespec,         /* get_timespec */
    2099         NULL,                           /* get_seconds */
    2100         NULL,                           /* seek_erf */
    2101         NULL,                           /* seek_timeval */
    2102         NULL,                           /* seek_seconds */
    2103         linuxring_get_capture_length,   /* get_capture_length */
    2104         linuxring_get_wire_length,      /* get_wire_length */
    2105         linuxring_get_framing_length,   /* get_framing_length */
    2106         linuxring_set_capture_length,   /* set_capture_length */
    2107         NULL,                           /* get_received_packets */
    2108         linuxnative_get_filtered_packets,/* get_filtered_packets */
    2109         linuxnative_get_dropped_packets,/* get_dropped_packets */
    2110         linuxnative_get_captured_packets,/* get_captured_packets */
    2111         linuxnative_get_fd,             /* get_fd */
    2112         NULL,                           /* trace_event */
    2113         linuxring_help,                 /* help */
    2114         NULL,                   /* next pointer */
    2115         NON_PARALLEL(true)
    2116 };
    2117 
    21181122#endif /* HAVE_NETPACKET_PACKET_H */
    21191123
     1124struct libtrace_format_t *get_native_format(void)
     1125{
     1126        return &linuxnative;
     1127}
     1128
    21201129
    21211130void linuxnative_constructor(void) {
    2122         /* TODO: once we're happy with ring:, it would be a good idea to
    2123          * swap the order of these calls so that ring: is preferred over
    2124          * int: if the user just gives an interface name as an input without
    2125          * explicitly choosing a format.
    2126          */
    21271131        register_format(&linuxnative);
    2128         register_format(&linuxring);
    2129 }
     1132}
  • lib/trace.c

    r04bf7c5 r035f8a7  
    143143                legacy_constructor();
    144144                atmhdr_constructor();
     145                linuxring_constructor();
    145146                linuxnative_constructor();
    146147#ifdef HAVE_LIBPCAP
Note: See TracChangeset for help on using the changeset viewer.