Changeset 6ba84d9 for lib/format_linux.c


Ignore:
Timestamp:
12/06/12 11:10:16 (8 years ago)
Author:
Shane Alcock <salcock@…>
Branches:
4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, getfragoff, help, 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:
90e8d92
Parents:
a464de7
Message:
  • Committed most of Perry's suggestions following a code review of the new ring: format
File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_linux.c

    rb4c3f61 r6ba84d9  
    7777 */
    7878#define MAX_ORDER 10
    79 static unsigned int max_order = MAX_ORDER;
    8079
    8180/* Cached page size, the page size shoudn't be changing */
     
    142141 * support the format directly.
    143142 */
     143
     144
    144145#define PACKET_RX_RING  5
    145146#define PACKET_VERSION  10
     
    152153#define TPACKET_ALIGNMENT       16
    153154#define TPACKET_ALIGN(x)        (((x)+TPACKET_ALIGNMENT-1)&~(TPACKET_ALIGNMENT-1))
    154 #define TPACKET2_HDRLEN         (TPACKET_ALIGN(sizeof(struct tpacket2_hdr)) + sizeof(struct sockaddr_ll))
     155#define TPACKET_HDRLEN         (TPACKET_ALIGN(sizeof(struct tpacket2_hdr)) + sizeof(struct sockaddr_ll))
    155156
    156157enum tpacket_versions {
     
    205206        /* The current frame number within the rx ring */       
    206207        int rxring_offset;
    207         /* The format this trace is using linuxring or linuxnative */
     208        /* The actual format being used - ring vs int */
    208209        libtrace_rt_types_t format;
    209210        /* The current ring buffer layout */
    210211        struct tpacket_req req;
     212        /* Used to determine buffer size for the ring buffer */
     213        uint32_t max_order;
    211214};
    212215
     
    254257        /* The format this trace is using linuxring or linuxnative */
    255258        libtrace_rt_types_t format;
     259        /* Used to determine buffer size for the ring buffer */
     260        uint32_t max_order;
    256261};
    257262
     
    259264#define GET_SOCKADDR_HDR(x)  ((struct sockaddr_ll *) (((char *) (x))\
    260265        + TPACKET_ALIGN(sizeof(struct tpacket2_hdr))))
    261 
    262 #define TPACKET_HDRLEN TPACKET2_HDRLEN
    263266
    264267#define FORMAT(x) ((struct linux_format_data_t*)(x))
     
    273276
    274277#ifdef HAVE_NETPACKET_PACKET_H
    275 
    276278/*
    277279 * Try figure out the best sizes for the ring buffer. Ensure that:
     
    286288 * - Calculates based on max_order and buf_min
    287289 */
    288 static void calculate_buffers(struct tpacket_req * req, int fd, char * uri){
     290static void calculate_buffers(struct tpacket_req * req, int fd, char * uri,
     291                uint32_t max_order){
    289292       
    290293        struct ifreq ifr;
    291         unsigned mtu = LIBTRACE_PACKET_BUFSIZE;
     294        unsigned max_frame = LIBTRACE_PACKET_BUFSIZE;
    292295        pagesize = getpagesize();
    293296
     297        strcpy(ifr.ifr_name, uri);
    294298        /* Don't bother trying to set frame size above mtu linux will drop
    295          * these anyway
     299         * these anyway.
     300         *
     301         * Remember, that our frame also has to include a TPACKET header!
    296302         */
    297         strcpy(ifr.ifr_name, uri);
    298303        if (ioctl(fd, SIOCGIFMTU, (caddr_t) &ifr) >= 0)
    299                 mtu = ifr.ifr_mtu;
    300         if(mtu > LIBTRACE_PACKET_BUFSIZE)
    301                 mtu = LIBTRACE_PACKET_BUFSIZE;
     304                max_frame = ifr.ifr_mtu + sizeof(struct tpacket2_hdr);
     305        if (max_frame > LIBTRACE_PACKET_BUFSIZE)
     306                max_frame = LIBTRACE_PACKET_BUFSIZE;
    302307
    303308        /* Calculate frame size */
    304309        req->tp_frame_size = pagesize;
    305         while(req->tp_frame_size < mtu && req->tp_frame_size < LIBTRACE_PACKET_BUFSIZE){
     310        while(req->tp_frame_size < max_frame &&
     311                        req->tp_frame_size < LIBTRACE_PACKET_BUFSIZE){
    306312                req->tp_frame_size <<= 1;
    307313        }
     
    326332                        (req->tp_block_size / req->tp_frame_size);
    327333
    328         /*printf("MaxO 0x%x BS 0x%x BN 0x%x FS 0x%x FN 0x%x\n",
     334        /*
     335        printf("MaxO 0x%x BS 0x%x BN 0x%x FS 0x%x FN 0x%x\n",
    329336                max_order,
    330337                req->tp_block_size,
    331338                req->tp_block_nr,
    332339                req->tp_frame_size,
    333                 req->tp_frame_nr);*/
     340                req->tp_frame_nr);
     341        */
    334342       
    335343        /* In case we have some silly values*/
     
    519527                                        int fd,
    520528                                        struct tpacket_req * req,
    521                                         char ** ring_location){
     529                                        char ** ring_location,
     530                                        uint32_t *max_order){
    522531        socklen_t len;
    523532        int val;
     
    547556         */
    548557        while(1) {     
    549                 if (max_order <= 0) {
     558                if (*max_order <= 0) {
    550559                        return -1;
    551560                }
    552                 calculate_buffers(req, fd, uridata);
     561                calculate_buffers(req, fd, uridata, *max_order);
    553562                if (setsockopt(fd,
    554563                                SOL_PACKET,
     
    557566                                sizeof(struct tpacket_req)) == -1) {
    558567                        if(errno == ENOMEM){
    559                                 max_order--;
     568                                (*max_order)--;
    560569                        } else {
    561570                                return -1;
     
    584593
    585594        /* Make it a packetmmap */
    586         if(socket_to_packetmmap(libtrace->uridata, PACKET_RX_RING, FORMAT(libtrace->format_data)->fd,
    587                  &FORMAT(libtrace->format_data)->req, &FORMAT(libtrace->format_data)->rx_ring) != 0){
     595        if(socket_to_packetmmap(libtrace->uridata, PACKET_RX_RING,
     596                        FORMAT(libtrace->format_data)->fd,
     597                        &FORMAT(libtrace->format_data)->req,
     598                        &FORMAT(libtrace->format_data)->rx_ring,
     599                        &FORMAT(libtrace->format_data)->max_order) != 0){
    588600                trace_set_err(libtrace, TRACE_ERR_INIT_FAILED,
    589601                        "TPACKET2 not supported or ring buffer is too large");
     
    592604                return -1;
    593605        }
    594                
     606
    595607        return 0;
    596608}
     
    614626
    615627        /* Make it a packetmmap */
    616         if(socket_to_packetmmap(libtrace->uridata, PACKET_TX_RING, DATAOUT(libtrace)->fd,
    617                  &DATAOUT(libtrace)->req, &DATAOUT(libtrace)->tx_ring) != 0){
     628        if(socket_to_packetmmap(libtrace->uridata, PACKET_TX_RING,
     629                        DATAOUT(libtrace)->fd,
     630                        &DATAOUT(libtrace)->req,
     631                        &DATAOUT(libtrace)->tx_ring,
     632                        &DATAOUT(libtrace)->max_order) != 0){
    618633                trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED,
    619634                        "TPACKET2 not supported or ring buffer is too large");
     
    834849                                        TO_TP_HDR(packet->header)->tp_mac,
    835850                                        TO_TP_HDR(packet->header)->tp_net,
    836                                         TPACKET2_HDRLEN);
     851                                        TPACKET_HDRLEN);
    837852        packet->type = rt_type;
    838853
     
    10241039                if (ret < 0) {
    10251040                        if (errno != EINTR)
    1026                         trace_set_err(libtrace,errno,"poll()");
     1041                                trace_set_err(libtrace,errno,"poll()");
    10271042                        return -1;
    10281043                }
     
    13331348{       
    13341349        /*
    1335          * Need to make frame_length + capture_length = compelete capture length
     1350         * Need to make frame_length + capture_length = complete capture length
    13361351         * so include alligment whitespace. So reverse calculate from packet.
    13371352         */
     
    16561671
    16571672void linuxnative_constructor(void) {
     1673        /* TODO: once we're happy with ring:, it would be a good idea to
     1674         * swap the order of these calls so that ring: is preferred over
     1675         * int: if the user just gives an interface name as an input without
     1676         * explicitly choosing a format.
     1677         */
    16581678        register_format(&linuxnative);
    16591679        register_format(&linuxring);
Note: See TracChangeset for help on using the changeset viewer.