Changeset d97778c


Ignore:
Timestamp:
01/15/15 17:13:58 (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:
18bf317
Parents:
97d170d
Message:

Code style fixes.

There are a couple of dubious lines in there that someone else might
like to change. Also, formatting relies on 8 space tabs which could be
improved by tabbing to the save level and spacing to line up with the
previous line when trying to break a function call across multiple lines.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_dag25.c

    r97d170d rd97778c  
    119119/* Data that is stored for each libtrace_thread_t */
    120120struct dag_per_thread_t {
    121         struct dag_dev_t *device; /* DAG device */
    122         uint16_t stream; /* Stream number */
    123         uint8_t *top; /* Pointer to the last unread byte in the DAG memory */
    124         uint8_t *bottom; /* Pointer to the first unread byte in the DAG memory */
    125         uint32_t processed; /* Amount of data processed from the bottom pointer */
    126         uint64_t pkt_count; /* Number of packets seen by the thread */
     121        /* DAG device */
     122        struct dag_dev_t *device;
     123        /* Stream number */
     124        uint16_t stream;
     125        /* Pointer to the last unread byte in the DAG memory */
     126        uint8_t *top;
     127        /* Pointer to the first unread byte in the DAG memory */
     128        uint8_t *bottom;
     129        /* Amount of data processed from the bottom pointer */
     130        uint32_t processed;
     131        /* Number of packets seen by the thread */
     132        uint64_t pkt_count;
     133        /* Drop count for this particular thread */
    127134        uint64_t drops;
    128135};
     
    130137/* "Global" data that is stored for each DAG input trace */
    131138struct dag_format_data_t {
    132 
    133139        /* Data required for regular DUCK reporting */
    134140        struct {
     
    136142                uint32_t last_duck;
    137143                /* The number of seconds between each DUCK report */
    138                 uint32_t duck_freq;
     144                uint32_t duck_freq;
    139145                /* Timestamp of the last packet read from the DAG card */
    140                 uint32_t last_pkt;
     146                uint32_t last_pkt;
    141147                /* Dummy trace to ensure DUCK packets are dealt with using the
    142148                 * DUCK format functions */
    143                 libtrace_t *dummy_duck;
    144         } duck;
     149                libtrace_t *dummy_duck;
     150        } duck;
    145151
    146152        /* The DAG device that we are reading from */
     
    158164        /* The number of packets that have been dropped */
    159165        uint64_t drops;
    160         /* When running in parallel mode this is malloc'd with an array of thread
    161          * structures. Most of the stuff above doesn't get used in parallel mode. */
     166        /* When running in parallel mode this is malloc'd with an
     167         * array of thread structures. Most of the stuff above doesn't
     168         * get used in parallel mode. */
    162169        struct dag_per_thread_t *per_thread;
    163170
     
    218225
    219226/* Initialises the DAG output data structure */
    220 static void dag_init_format_out_data(libtrace_out_t *libtrace) {
    221         libtrace->format_data = (struct dag_format_data_out_t *) malloc(sizeof(struct dag_format_data_out_t));
     227static void dag_init_format_out_data(libtrace_out_t *libtrace)
     228{
     229        libtrace->format_data = (struct dag_format_data_out_t *)
     230                malloc(sizeof(struct dag_format_data_out_t));
    222231        // no DUCK on output
    223232        FORMAT_DATA_OUT->stream_attached = 0;
     
    229238
    230239/* Initialises the DAG input data structure */
    231 static void dag_init_format_data(libtrace_t *libtrace) {
     240static void dag_init_format_data(libtrace_t *libtrace)
     241{
    232242        libtrace->format_data = (struct dag_format_data_t *)
    233243                malloc(sizeof(struct dag_format_data_t));
    234244        DUCK.last_duck = 0;
    235         DUCK.duck_freq = 0;
    236         DUCK.last_pkt = 0;
    237         DUCK.dummy_duck = NULL;
     245        DUCK.duck_freq = 0;
     246        DUCK.last_pkt = 0;
     247        DUCK.dummy_duck = NULL;
    238248        FORMAT_DATA->stream_attached = 0;
    239249        FORMAT_DATA->drops = 0;
     
    243253        FORMAT_DATA->bottom = NULL;
    244254        FORMAT_DATA->top = NULL;
    245         memset(FORMAT_DATA->seeninterface, 0, sizeof(FORMAT_DATA->seeninterface));
     255        memset(FORMAT_DATA->seeninterface, 0,
     256               sizeof(FORMAT_DATA->seeninterface));
    246257}
    247258
     
    250261 *
    251262 * NOTE: This function assumes the open_dag_mutex is held by the caller */
    252 static struct dag_dev_t *dag_find_open_device(char *dev_name) {
     263static struct dag_dev_t *dag_find_open_device(char *dev_name)
     264{
    253265        struct dag_dev_t *dag_dev;
    254266
     
    261273                        dag_dev->ref_count ++;
    262274                        return dag_dev;
    263 
    264275                }
    265276                dag_dev = dag_dev->next;
    266277        }
    267278        return NULL;
    268 
    269 
    270279}
    271280
     
    276285 *
    277286 * NOTE: This function assumes the open_dag_mutex is held by the caller */
    278 static void dag_close_device(struct dag_dev_t *dev) {
     287static void dag_close_device(struct dag_dev_t *dev)
     288{
    279289        /* Need to remove from the device list */
    280 
    281290        assert(dev->ref_count == 0);
    282291
     
    301310 *
    302311 * NOTE: this function should only be called when opening a DAG device for
    303  * writing - there is little practical difference between this and the 
     312 * writing - there is little practical difference between this and the
    304313 * function below that covers the reading case, but we need the output trace
    305  * object to report errors properly so the two functions take slightly 
     314 * object to report errors properly so the two functions take slightly
    306315 * different arguments. This is really lame and there should be a much better
    307316 * way of doing this.
    308317 *
    309  * NOTE: This function assumes the open_dag_mutex is held by the caller 
     318 * NOTE: This function assumes the open_dag_mutex is held by the caller
    310319 */
    311 static struct dag_dev_t *dag_open_output_device(libtrace_out_t *libtrace, char *dev_name) {
     320static struct dag_dev_t *dag_open_output_device(libtrace_out_t *libtrace,
     321                                                char *dev_name)
     322{
    312323        struct stat buf;
    313324        int fd;
     
    318329                trace_set_err_out(libtrace,errno,"stat(%s)",dev_name);
    319330                return NULL;
    320 }
     331        }
    321332
    322333        /* Make sure it is the appropriate type of device */
     
    355366 *
    356367 * NOTE: this function should only be called when opening a DAG device for
    357  * reading - there is little practical difference between this and the 
     368 * reading - there is little practical difference between this and the
    358369 * function above that covers the writing case, but we need the input trace
    359  * object to report errors properly so the two functions take slightly 
     370 * object to report errors properly so the two functions take slightly
    360371 * different arguments. This is really lame and there should be a much better
    361372 * way of doing this.
     
    368379
    369380        /* Make sure the device exists */
    370         if (stat(dev_name, &buf) == -1) {
    371                 trace_set_err(libtrace,errno,"stat(%s)",dev_name);
    372                 return NULL;
    373         }
     381        if (stat(dev_name, &buf) == -1) {
     382                trace_set_err(libtrace,errno,"stat(%s)",dev_name);
     383                return NULL;
     384        }
    374385
    375386        /* Make sure it is the appropriate type of device */
     
    377388                /* Try opening the DAG device */
    378389                if((fd = dag_open(dev_name)) < 0) {
    379                         trace_set_err(libtrace,errno,"Cannot open DAG %s",
    380                                         dev_name);
    381                         return NULL;
    382                 }
     390                        trace_set_err(libtrace,errno,"Cannot open DAG %s",
     391                                      dev_name);
     392                        return NULL;
     393                }
    383394        } else {
    384395                trace_set_err(libtrace,errno,"Not a valid dag device: %s",
    385                                 dev_name);
    386                 return NULL;
    387         }
     396                              dev_name);
     397                return NULL;
     398        }
    388399
    389400        /* Add the device to our device list - it is just a doubly linked
     
    406417
    407418/* Creates and initialises a DAG output trace */
    408 static int dag_init_output(libtrace_out_t *libtrace) {
     419static int dag_init_output(libtrace_out_t *libtrace)
     420{
    409421        char *dag_dev_name = NULL;
    410422        char *scan = NULL;
    411423        struct dag_dev_t *dag_device = NULL;
    412424        int stream = 1;
    413        
     425
    414426        /* XXX I don't know if this is important or not, but this function
    415427         * isn't present in all of the driver releases that this code is
     
    421433
    422434        dag_init_format_out_data(libtrace);
    423         /* Grab the mutex while we're likely to be messing with the device 
     435        /* Grab the mutex while we're likely to be messing with the device
    424436         * list */
    425437        pthread_mutex_lock(&open_dag_mutex);
    426        
     438
    427439        /* Specific streams are signified using a comma in the libtrace URI,
    428440         * e.g. dag:/dev/dag0,1 refers to stream 1 on the dag0 device.
     
    466478/* Creates and initialises a DAG input trace */
    467479static int dag_init_input(libtrace_t *libtrace) {
    468         char *dag_dev_name = NULL;
     480        char *dag_dev_name = NULL;
    469481        char *scan = NULL;
    470482        int stream = 0, thread_count = 1;
     
    472484
    473485        dag_init_format_data(libtrace);
    474         /* Grab the mutex while we're likely to be messing with the device 
     486        /* Grab the mutex while we're likely to be messing with the device
    475487         * list */
    476488        pthread_mutex_lock(&open_dag_mutex);
     
    481493         * e.g. dag:/dev/dag0,2 refers to stream 2 on the dag0 device.
    482494         *
    483          * If no stream is specified, we will read from stream 0 with one thread
     495         * If no stream is specified, we will read from stream 0 with
     496         * one thread
    484497         */
    485498        if ((scan = strchr(libtrace->uridata, ',')) == NULL) {
    486499                dag_dev_name = strdup(libtrace->uridata);
    487                
    488500        } else {
    489501                dag_dev_name = (char *)strndup(libtrace->uridata,
    490                                                                            (size_t)(scan - libtrace->uridata));
     502                                               (size_t)(scan -
     503                                                        libtrace->uridata));
    491504                stream = atoi(++scan);
    492505        }
     
    517530        FORMAT_DATA->device = dag_device;
    518531
    519         /* See Config_Status_API_Programming_Guide.pdf from the Endace Dag Documentation */
    520         /* Check kBooleanAttributeActive is true -- no point capturing on an interface that's disabled
    521  
    522         *  The symptom of the port being disabled is that libtrace will appear to hang.
    523         */
     532        /* See Config_Status_API_Programming_Guide.pdf from the Endace
     533           Dag Documentation */
     534        /* Check kBooleanAttributeActive is true -- no point capturing
     535         * on an interface that's disabled
     536         *
     537         * The symptom of the port being disabled is that libtrace
     538         * will appear to hang. */
    524539        /* Check kBooleanAttributeFault is false */
    525540        /* Check kBooleanAttributeLocalFault is false */
     
    527542        /* Check kBooleanAttributePeerLink ? */
    528543
    529         /* Set kBooleanAttributePromisc/kBooleanPromiscuousMode based on libtrace promisc attribute?*/
     544        /* Set kBooleanAttributePromisc/kBooleanPromiscuousMode based
     545           on libtrace promisc attribute?*/
    530546        /* Set kUint32AttributeSnapLength to the snaplength */
    531547
    532548        pthread_mutex_unlock(&open_dag_mutex);
    533         return 0;
     549        return 0;
    534550}
    535551
    536552/* Configures a DAG input trace */
    537553static int dag_config_input(libtrace_t *libtrace, trace_option_t option,
    538                                 void *data) {
    539         char conf_str[4096];
     554                            void *data)
     555{
     556        char conf_str[4096];
    540557        switch(option) {
    541                 case TRACE_OPTION_META_FREQ:
    542                         /* This option is used to specify the frequency of DUCK
    543                          * updates */
    544                         DUCK.duck_freq = *(int *)data;
    545                         return 0;
    546                 case TRACE_OPTION_SNAPLEN:
    547                         /* Tell the card our new snap length */
    548                         snprintf(conf_str, 4096, "varlen slen=%i", *(int *)data);
    549                         if (dag_configure(FORMAT_DATA->device->fd,
    550                                                 conf_str) != 0) {
    551                                 trace_set_err(libtrace, errno, "Failed to configure snaplen on DAG card: %s", libtrace->uridata);
    552                                 return -1;
    553                         }
    554                         return 0;
    555                 case TRACE_OPTION_PROMISC:
    556                         /* DAG already operates in a promisc fashion */
    557                         return -1;
    558                 case TRACE_OPTION_FILTER:
    559                         /* We don't yet support pushing filters into DAG
    560                          * cards */
    561                         return -1;
    562                 case TRACE_OPTION_EVENT_REALTIME:
    563                         /* Live capture is always going to be realtime */
     558        case TRACE_OPTION_META_FREQ:
     559                /* This option is used to specify the frequency of DUCK
     560                 * updates */
     561                DUCK.duck_freq = *(int *)data;
     562                return 0;
     563        case TRACE_OPTION_SNAPLEN:
     564                /* Tell the card our new snap length */
     565                snprintf(conf_str, 4096, "varlen slen=%i", *(int *)data);
     566                if (dag_configure(FORMAT_DATA->device->fd,
     567                                  conf_str) != 0) {
     568                        trace_set_err(libtrace, errno, "Failed to configure "
     569                                      "snaplen on DAG card: %s",
     570                                      libtrace->uridata);
    564571                        return -1;
    565         }
     572                }
     573                return 0;
     574        case TRACE_OPTION_PROMISC:
     575                /* DAG already operates in a promisc fashion */
     576                return -1;
     577        case TRACE_OPTION_FILTER:
     578                /* We don't yet support pushing filters into DAG
     579                 * cards */
     580                return -1;
     581        case TRACE_OPTION_EVENT_REALTIME:
     582                /* Live capture is always going to be realtime */
     583                return -1;
     584        }
    566585        return -1;
    567586}
    568587
    569588/* Starts a DAG output trace */
    570 static int dag_start_output(libtrace_out_t *libtrace) {
     589static int dag_start_output(libtrace_out_t *libtrace)
     590{
    571591        struct timeval zero, nopoll;
    572592
     
    576596
    577597        /* Attach and start the DAG stream */
    578 
    579598        if (dag_attach_stream(FORMAT_DATA_OUT->device->fd,
    580599                        FORMAT_DATA_OUT->dagstream, 0, 4 * 1024 * 1024) < 0) {
     
    591610
    592611        /* We don't want the dag card to do any sleeping */
    593 
    594612        dag_set_stream_poll(FORMAT_DATA_OUT->device->fd,
    595613                        FORMAT_DATA_OUT->dagstream, 0, &zero,
     
    600618
    601619/* Starts a DAG input trace */
    602 static int dag_start_input(libtrace_t *libtrace) {
    603         struct timeval zero, nopoll;
    604         uint8_t *top, *bottom, *starttop;
     620static int dag_start_input(libtrace_t *libtrace)
     621{
     622        struct timeval zero, nopoll;
     623        uint8_t *top, *bottom, *starttop;
    605624        uint64_t diff = 0;
    606625        top = bottom = NULL;
    607626
    608627        zero.tv_sec = 0;
    609         zero.tv_usec = 10000;
    610         nopoll = zero;
     628        zero.tv_usec = 10000;
     629        nopoll = zero;
    611630
    612631        /* Attach and start the DAG stream */
    613632        if (dag_attach_stream(FORMAT_DATA->device->fd,
    614                                 FORMAT_DATA->dagstream, 0, 0) < 0) {
    615                 trace_set_err(libtrace, errno, "Cannot attach DAG stream");
    616                 return -1;
    617         }
     633                              FORMAT_DATA->dagstream, 0, 0) < 0) {
     634                trace_set_err(libtrace, errno, "Cannot attach DAG stream");
     635                return -1;
     636        }
    618637
    619638        if (dag_start_stream(FORMAT_DATA->device->fd,
    620                                 FORMAT_DATA->dagstream) < 0) {
    621                 trace_set_err(libtrace, errno, "Cannot start DAG stream");
    622                 return -1;
    623         }
     639                             FORMAT_DATA->dagstream) < 0) {
     640                trace_set_err(libtrace, errno, "Cannot start DAG stream");
     641                return -1;
     642        }
    624643        FORMAT_DATA->stream_attached = 1;
    625        
     644
    626645        /* We don't want the dag card to do any sleeping */
    627         dag_set_stream_poll(FORMAT_DATA->device->fd,
    628                                 FORMAT_DATA->dagstream, 0, &zero,
    629                                 &nopoll);
     646        dag_set_stream_poll(FORMAT_DATA->device->fd,
     647                            FORMAT_DATA->dagstream, 0, &zero,
     648                            &nopoll);
    630649
    631650        starttop = dag_advance_stream(FORMAT_DATA->device->fd,
    632                                         FORMAT_DATA->dagstream,
    633                                         &bottom);
     651                                      FORMAT_DATA->dagstream,
     652                                      &bottom);
    634653
    635654        /* Should probably flush the memory hole now */
     
    637656                bottom += (starttop - bottom);
    638657                top = dag_advance_stream(FORMAT_DATA->device->fd,
    639                                         FORMAT_DATA->dagstream,
    640                                         &bottom);
     658                                         FORMAT_DATA->dagstream,
     659                                         &bottom);
    641660        }
    642661        FORMAT_DATA->top = top;
     
    649668
    650669/* Pauses a DAG output trace */
    651 static int dag_pause_output(libtrace_out_t *libtrace) {
    652 
     670static int dag_pause_output(libtrace_out_t *libtrace)
     671{
    653672        /* Stop and detach the stream */
    654673        if (dag_stop_stream(FORMAT_DATA_OUT->device->fd,
    655                         FORMAT_DATA_OUT->dagstream) < 0) {
     674                            FORMAT_DATA_OUT->dagstream) < 0) {
    656675                trace_set_err_out(libtrace, errno, "Could not stop DAG stream");
    657676                return -1;
    658677        }
    659678        if (dag_detach_stream(FORMAT_DATA_OUT->device->fd,
    660                         FORMAT_DATA_OUT->dagstream) < 0) {
    661                 trace_set_err_out(libtrace, errno, "Could not detach DAG stream");
     679                              FORMAT_DATA_OUT->dagstream) < 0) {
     680                trace_set_err_out(libtrace, errno,
     681                                  "Could not detach DAG stream");
    662682                return -1;
    663683        }
     
    667687
    668688/* Pauses a DAG input trace */
    669 static int dag_pause_input(libtrace_t *libtrace) {
    670 
     689static int dag_pause_input(libtrace_t *libtrace)
     690{
    671691        /* Stop and detach the stream */
    672692        if (dag_stop_stream(FORMAT_DATA->device->fd,
    673                                 FORMAT_DATA->dagstream) < 0) {
    674                 trace_set_err(libtrace, errno, "Could not stop DAG stream");
    675                 return -1;
    676         }
    677         if (dag_detach_stream(FORMAT_DATA->device->fd,
    678                                 FORMAT_DATA->dagstream) < 0) {
    679                 trace_set_err(libtrace, errno, "Could not detach DAG stream");
    680                 return -1;
     693                            FORMAT_DATA->dagstream) < 0) {
     694                trace_set_err(libtrace, errno, "Could not stop DAG stream");
     695                return -1;
     696        }
     697        if (dag_detach_stream(FORMAT_DATA->device->fd,
     698                              FORMAT_DATA->dagstream) < 0) {
     699                trace_set_err(libtrace, errno, "Could not detach DAG stream");
     700                return -1;
    681701        }
    682702        FORMAT_DATA->stream_attached = 0;
     
    685705
    686706/* Closes a DAG input trace */
    687 static int dag_fin_input(libtrace_t *libtrace) {
     707static int dag_fin_input(libtrace_t *libtrace)
     708{
    688709        /* Need the lock, since we're going to be handling the device list */
    689710        pthread_mutex_lock(&open_dag_mutex);
    690        
     711
    691712        /* Detach the stream if we are not paused */
    692713        if (FORMAT_DATA->stream_attached)
     
    701722        free(libtrace->format_data);
    702723        pthread_mutex_unlock(&open_dag_mutex);
    703         return 0; /* success */
     724        return 0; /* success */
    704725}
    705726
    706727/* Closes a DAG output trace */
    707 static int dag_fin_output(libtrace_out_t *libtrace) {
    708        
     728static int dag_fin_output(libtrace_out_t *libtrace)
     729{
     730
    709731        /* Commit any outstanding traffic in the txbuffer */
    710732        if (FORMAT_DATA_OUT->waiting) {
    711                 dag_tx_stream_commit_bytes(FORMAT_DATA_OUT->device->fd, FORMAT_DATA_OUT->dagstream,
    712                                 FORMAT_DATA_OUT->waiting );
    713         }
    714 
    715         /* Wait until the buffer is nearly clear before exiting the program,
     733                dag_tx_stream_commit_bytes(FORMAT_DATA_OUT->device->fd,
     734                                           FORMAT_DATA_OUT->dagstream,
     735                                           FORMAT_DATA_OUT->waiting );
     736        }
     737
     738        /* Wait until the buffer is nearly clear before exiting the program,
    716739         * as we will lose packets otherwise */
    717         dag_tx_get_stream_space(FORMAT_DATA_OUT->device->fd,
    718                         FORMAT_DATA_OUT->dagstream,
    719                         dag_get_stream_buffer_size(FORMAT_DATA_OUT->device->fd,
    720                                         FORMAT_DATA_OUT->dagstream) - 8
    721                         );
     740        dag_tx_get_stream_space
     741                (FORMAT_DATA_OUT->device->fd,
     742                 FORMAT_DATA_OUT->dagstream,
     743                 dag_get_stream_buffer_size(FORMAT_DATA_OUT->device->fd,
     744                                            FORMAT_DATA_OUT->dagstream) - 8);
    722745
    723746        /* Need the lock, since we're going to be handling the device list */
     
    738761
    739762/* Extracts DUCK information from the DAG card and produces a DUCK packet */
    740 static int dag_get_duckinfo(libtrace_t *libtrace,
    741                                 libtrace_packet_t *packet) {
    742 
     763static int dag_get_duckinfo(libtrace_t *libtrace, libtrace_packet_t *packet)
     764{
    743765        /* Allocate memory for the DUCK data */
    744         if (packet->buf_control == TRACE_CTRL_EXTERNAL ||
    745                         !packet->buffer) {
    746                 packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
    747                 packet->buf_control = TRACE_CTRL_PACKET;
    748                 if (!packet->buffer) {
    749                         trace_set_err(libtrace, errno,
    750                                         "Cannot allocate packet buffer");
    751                         return -1;
    752                 }
    753         }
     766        if (packet->buf_control == TRACE_CTRL_EXTERNAL ||
     767            !packet->buffer) {
     768                packet->buffer = malloc(LIBTRACE_PACKET_BUFSIZE);
     769                packet->buf_control = TRACE_CTRL_PACKET;
     770                if (!packet->buffer) {
     771                        trace_set_err(libtrace, errno,
     772                                      "Cannot allocate packet buffer");
     773                        return -1;
     774                }
     775        }
    754776
    755777        /* DUCK doesn't have a format header */
    756         packet->header = 0;
    757         packet->payload = packet->buffer;
    758 
    759         /* No need to check if we can get DUCK or not - we're modern
    760         * enough so just grab the DUCK info */
    761         if ((ioctl(FORMAT_DATA->device->fd, DAGIOCDUCK,
    762                                         (duckinf_t *)packet->payload) < 0)) {
    763                 trace_set_err(libtrace, errno, "Error using DAGIOCDUCK");
    764                 return -1;
    765         }
    766 
    767         packet->type = TRACE_RT_DUCK_2_5;
     778        packet->header = 0;
     779        packet->payload = packet->buffer;
     780
     781        /* No need to check if we can get DUCK or not - we're modern
     782        * enough so just grab the DUCK info */
     783        if ((ioctl(FORMAT_DATA->device->fd, DAGIOCDUCK,
     784                   (duckinf_t *)packet->payload) < 0)) {
     785                trace_set_err(libtrace, errno, "Error using DAGIOCDUCK");
     786                return -1;
     787        }
     788
     789        packet->type = TRACE_RT_DUCK_2_5;
    768790
    769791        /* Set the packet's tracce to point at a DUCK trace, so that the
    770792         * DUCK format functions will be called on the packet rather than the
    771793         * DAG ones */
    772         if (!DUCK.dummy_duck)
    773                 DUCK.dummy_duck = trace_create_dead("rt:localhost:3434");
    774         packet->trace = DUCK.dummy_duck;
    775         return sizeof(duckinf_t);
     794        if (!DUCK.dummy_duck)
     795                DUCK.dummy_duck = trace_create_dead("rt:localhost:3434");
     796        packet->trace = DUCK.dummy_duck;
     797        return sizeof(duckinf_t);
    776798}
    777799
    778800/* Determines the amount of data available to read from the DAG card */
    779 static int dag_available(libtrace_t *libtrace) {
     801static int dag_available(libtrace_t *libtrace)
     802{
    780803        uint32_t diff = FORMAT_DATA->top - FORMAT_DATA->bottom;
    781804
     
    785808        if (diff >= dag_record_size && FORMAT_DATA->processed < 4 * 1024 * 1024)
    786809                return diff;
    787        
     810
    788811        /* Update the top and bottom pointers */
    789812        FORMAT_DATA->top = dag_advance_stream(FORMAT_DATA->device->fd,
    790                         FORMAT_DATA->dagstream,
    791                         &(FORMAT_DATA->bottom));
    792        
     813                                              FORMAT_DATA->dagstream,
     814                                              &(FORMAT_DATA->bottom));
     815
    793816        if (FORMAT_DATA->top == NULL) {
    794817                trace_set_err(libtrace, errno, "dag_advance_stream failed!");
     
    801824
    802825/* Returns a pointer to the start of the next complete ERF record */
    803 static dag_record_t *dag_get_record(libtrace_t *libtrace) {
    804         dag_record_t *erfptr = NULL;
    805         uint16_t size;
     826static dag_record_t *dag_get_record(libtrace_t *libtrace)
     827{
     828        dag_record_t *erfptr = NULL;
     829        uint16_t size;
     830
    806831        erfptr = (dag_record_t *)FORMAT_DATA->bottom;
    807832        if (!erfptr)
    808                 return NULL;
    809         size = ntohs(erfptr->rlen);
    810         assert( size >= dag_record_size );
     833                return NULL;
     834
     835        size = ntohs(erfptr->rlen);
     836        assert( size >= dag_record_size );
     837
    811838        /* Make certain we have the full packet available */
    812839        if (size > (FORMAT_DATA->top - FORMAT_DATA->bottom))
    813840                return NULL;
     841
    814842        FORMAT_DATA->bottom += size;
    815843        FORMAT_DATA->processed += size;
     
    820848 * libtrace packet */
    821849static int dag_prepare_packet(libtrace_t *libtrace, libtrace_packet_t *packet,
    822                 void *buffer, libtrace_rt_types_t rt_type, uint32_t flags) {
    823 
     850                              void *buffer, libtrace_rt_types_t rt_type,
     851                              uint32_t flags)
     852{
    824853        dag_record_t *erfptr;
    825854        libtrace_thread_t *t;
    826        
     855
    827856        /* If the packet previously owned a buffer that is not the buffer
    828         * that contains the new packet data, we're going to need to free the
    829         * old one to avoid memory leaks */
     857        * that contains the new packet data, we're going to need to free the
     858        * old one to avoid memory leaks */
    830859        if (packet->buffer != buffer &&
    831860                        packet->buf_control == TRACE_CTRL_PACKET) {
     
    842871        erfptr = (dag_record_t *)buffer;
    843872        packet->buffer = erfptr;
    844         packet->header = erfptr;
    845         packet->type = rt_type;
     873        packet->header = erfptr;
     874        packet->type = rt_type;
    846875
    847876        if (erfptr->flags.rxerror == 1) {
    848                 /* rxerror means the payload is corrupt - drop the payload
    849                 * by tweaking rlen */
    850                 packet->payload = NULL;
    851                 erfptr->rlen = htons(erf_get_framing_length(packet));
    852         } else {
    853                 packet->payload = (char*)packet->buffer
    854                         + erf_get_framing_length(packet);
    855         }
     877                /* rxerror means the payload is corrupt - drop the payload
     878                * by tweaking rlen */
     879                packet->payload = NULL;
     880                erfptr->rlen = htons(erf_get_framing_length(packet));
     881        } else {
     882                packet->payload = (char*)packet->buffer
     883                        + erf_get_framing_length(packet);
     884        }
    856885
    857886        if (libtrace->format_data == NULL) {
     
    860889
    861890        /* Update the dropped packets counter */
    862         /* No loss counter for DSM coloured records - have to use
    863          * some other API */
    864         /* Adding multithread support for this isn't actually that useful for the
    865          * DAG7.5G2, as there's no way to use multiple receive streams without DSM */
     891        /* No loss counter for DSM coloured records - have to use some
     892         * other API */
    866893        if (erfptr->type == TYPE_DSM_COLOR_ETH) {
    867894                /* TODO */
     
    872899                        PERPKT_DATA(t)->drops += ntohs(erfptr->lctr);
    873900                } else {
    874                         if (FORMAT_DATA->seeninterface[erfptr->flags.iface] == 0) {
    875                                 FORMAT_DATA->seeninterface[erfptr->flags.iface] = 1;
     901                        if (FORMAT_DATA->seeninterface[erfptr->flags.iface]
     902                            == 0) {
     903                                FORMAT_DATA->seeninterface[erfptr->flags.iface]
     904                                        = 1;
    876905                        } else {
    877906                                FORMAT_DATA->drops += ntohs(erfptr->lctr);
     
    879908                }
    880909        }
    881 
    882910
    883911        return 0;
     
    894922/* Pushes an ERF record onto the transmit stream */
    895923static int dag_dump_packet(libtrace_out_t *libtrace,
    896                 dag_record_t *erfptr, unsigned int pad, void *buffer) {
     924                           dag_record_t *erfptr, unsigned int pad,
     925                           void *buffer)
     926{
    897927        int size;
    898928
    899929        /*
    900          * If we've got 0 bytes waiting in the txqueue, assume that we haven't
    901          * requested any space yet, and request some, storing the pointer at
    902          * FORMAT_DATA_OUT->txbuffer.
     930         * If we've got 0 bytes waiting in the txqueue, assume that we
     931         * haven't requested any space yet, and request some, storing
     932         * the pointer at FORMAT_DATA_OUT->txbuffer.
    903933         *
    904934         * The amount to request is slightly magical at the moment - it's
     
    907937         */
    908938        if (FORMAT_DATA_OUT->waiting == 0) {
    909                 FORMAT_DATA_OUT->txbuffer = dag_tx_get_stream_space(FORMAT_DATA_OUT->device->fd,
    910                                 FORMAT_DATA_OUT->dagstream, 16908288);
     939                FORMAT_DATA_OUT->txbuffer =
     940                        dag_tx_get_stream_space(FORMAT_DATA_OUT->device->fd,
     941                                                FORMAT_DATA_OUT->dagstream,
     942                                                16908288);
    911943        }
    912944
     
    915947         * are in contiguous memory
    916948         */
    917         memcpy(FORMAT_DATA_OUT->txbuffer + FORMAT_DATA_OUT->waiting,erfptr,(dag_record_size + pad));
     949        memcpy(FORMAT_DATA_OUT->txbuffer + FORMAT_DATA_OUT->waiting, erfptr,
     950               (dag_record_size + pad));
    918951        FORMAT_DATA_OUT->waiting += (dag_record_size + pad);
    919 
    920 
    921952
    922953        /*
     
    925956         */
    926957        size = ntohs(erfptr->rlen)-(dag_record_size + pad);
    927         memcpy(FORMAT_DATA_OUT->txbuffer + FORMAT_DATA_OUT->waiting,buffer,size);
     958        memcpy(FORMAT_DATA_OUT->txbuffer + FORMAT_DATA_OUT->waiting, buffer,
     959               size);
    928960        FORMAT_DATA_OUT->waiting += size;
    929961
     
    934966         * case there is still data in the buffer at program exit.
    935967         */
    936 
    937968        if (FORMAT_DATA_OUT->waiting >= 16*1024*1024) {
    938                 FORMAT_DATA_OUT->txbuffer = dag_tx_stream_commit_bytes(FORMAT_DATA_OUT->device->fd, FORMAT_DATA_OUT->dagstream,
    939                         FORMAT_DATA_OUT->waiting );
     969                FORMAT_DATA_OUT->txbuffer =
     970                        dag_tx_stream_commit_bytes(FORMAT_DATA_OUT->device->fd,
     971                                                   FORMAT_DATA_OUT->dagstream,
     972                                                   FORMAT_DATA_OUT->waiting);
    940973                FORMAT_DATA_OUT->waiting = 0;
    941974        }
    942975
    943976        return size + pad + dag_record_size;
    944 
    945977}
    946978
     
    948980 * if one is found, false otherwise */
    949981static bool find_compatible_linktype(libtrace_out_t *libtrace,
    950                                 libtrace_packet_t *packet, char *type)
    951 {
    952          // Keep trying to simplify the packet until we can find
    953          //something we can do with it
     982                                     libtrace_packet_t *packet, char *type)
     983{
     984        /* Keep trying to simplify the packet until we can find
     985         * something we can do with it */
    954986
    955987        do {
    956                 *type=libtrace_to_erf_type(trace_get_link_type(packet));
    957 
    958                 // Success
     988                *type = libtrace_to_erf_type(trace_get_link_type(packet));
     989
     990                /* Success */
    959991                if (*type != (char)-1)
    960992                        return true;
     
    962994                if (!demote_packet(packet)) {
    963995                        trace_set_err_out(libtrace,
    964                                         TRACE_ERR_NO_CONVERSION,
    965                                         "No erf type for packet (%i)",
    966                                         trace_get_link_type(packet));
     996                                          TRACE_ERR_NO_CONVERSION,
     997                                          "No erf type for packet (%i)",
     998                                          trace_get_link_type(packet));
    967999                        return false;
    9681000                }
     
    9741006
    9751007/* Writes a packet to the provided DAG output trace */
    976 static int dag_write_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet) {
    977         /*
    978          * This is heavily borrowed from erf_write_packet(). Yes, CnP coding
    979          * sucks, sorry about that.
     1008static int dag_write_packet(libtrace_out_t *libtrace, libtrace_packet_t *packet)
     1009{
     1010        /* This is heavily borrowed from erf_write_packet(). Yes, CnP
     1011         * coding sucks, sorry about that.
    9801012         */
    9811013        unsigned int pad = 0;
     
    9861018
    9871019        if(!packet->header) {
    988                 /* No header, probably an RT packet. Lifted from 
     1020                /* No header, probably an RT packet. Lifted from
    9891021                 * erf_write_packet(). */
    9901022                return -1;
     
    10051037
    10061038        if (packet->type == TRACE_RT_DATA_ERF) {
    1007                 numbytes = dag_dump_packet(libtrace,
    1008                                 header,
    1009                                 pad,
    1010                                 payload
    1011                                 );
    1012 
     1039                numbytes = dag_dump_packet(libtrace, header, pad, payload);
    10131040        } else {
    10141041                /* Build up a new packet header from the existing header */
    10151042
    1016                 /* Simplify the packet first - if we can't do this, break 
     1043                /* Simplify the packet first - if we can't do this, break
    10171044                 * early */
    10181045                if (!find_compatible_linktype(libtrace,packet,&erf_type))
     
    10331060
    10341061                /* Packet length (rlen includes format overhead) */
    1035                 assert(trace_get_capture_length(packet)>0
    1036                                 && trace_get_capture_length(packet)<=65536);
    1037                 assert(erf_get_framing_length(packet)>0
    1038                                 && trace_get_framing_length(packet)<=65536);
    1039                 assert(trace_get_capture_length(packet)+erf_get_framing_length(packet)>0
    1040                       &&trace_get_capture_length(packet)+erf_get_framing_length(packet)<=65536);
     1062                assert(trace_get_capture_length(packet) > 0
     1063                       && trace_get_capture_length(packet) <= 65536);
     1064                assert(erf_get_framing_length(packet) > 0
     1065                       && trace_get_framing_length(packet) <= 65536);
     1066                assert(trace_get_capture_length(packet) +
     1067                       erf_get_framing_length(packet) > 0
     1068                       && trace_get_capture_length(packet) +
     1069                       erf_get_framing_length(packet) <= 65536);
    10411070
    10421071                erfhdr.rlen = htons(trace_get_capture_length(packet)
    1043                         + erf_get_framing_length(packet));
     1072                                    + erf_get_framing_length(packet));
    10441073
    10451074
     
    10501079
    10511080                /* Write it out */
    1052                 numbytes = dag_dump_packet(libtrace,
    1053                                 &erfhdr,
    1054                                 pad,
    1055                                 payload);
    1056 
     1081                numbytes = dag_dump_packet(libtrace, &erfhdr, pad, payload);
    10571082        }
    10581083
     
    10641089 * If DUCK reporting is enabled, the packet returned may be a DUCK update
    10651090 */
    1066 static int dag_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    1067         int size = 0;
    1068         struct timeval tv;
    1069         dag_record_t *erfptr = NULL;
     1091static int dag_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet)
     1092{
     1093        int size = 0;
     1094        struct timeval tv;
     1095        dag_record_t *erfptr = NULL;
    10701096        int numbytes = 0;
    10711097        uint32_t flags = 0;
     
    10781104        maxwait.tv_usec = 250000;
    10791105
    1080         /* Check if we're due for a DUCK report */
     1106        /* Check if we're due for a DUCK report */
    10811107        if (DUCK.last_pkt - DUCK.last_duck > DUCK.duck_freq &&
    1082                         DUCK.duck_freq != 0) {
    1083                 size = dag_get_duckinfo(libtrace, packet);
    1084                 DUCK.last_duck = DUCK.last_pkt;
    1085                 if (size != 0) {
    1086                         return size;
    1087                 }
    1088                 /* No DUCK support, so don't waste our time anymore */
    1089                 DUCK.duck_freq = 0;
    1090         }
     1108            DUCK.duck_freq != 0) {
     1109                size = dag_get_duckinfo(libtrace, packet);
     1110                DUCK.last_duck = DUCK.last_pkt;
     1111                if (size != 0) {
     1112                        return size;
     1113                }
     1114                /* No DUCK support, so don't waste our time anymore */
     1115                DUCK.duck_freq = 0;
     1116        }
    10911117
    10921118        /* Don't let anyone try to free our DAG memory hole! */
     
    10951121        /* If the packet buffer is currently owned by libtrace, free it so
    10961122         * that we can set the packet to point into the DAG memory hole */
    1097         if (packet->buf_control == TRACE_CTRL_PACKET) {
    1098                 free(packet->buffer);
    1099                 packet->buffer = 0;
    1100         }
    1101        
    1102         if (dag_set_stream_poll(FORMAT_DATA->device->fd,
    1103                         FORMAT_DATA->dagstream, sizeof(dag_record_t), &maxwait,
    1104                         &pollwait) == -1)
    1105         {
     1123        if (packet->buf_control == TRACE_CTRL_PACKET) {
     1124                free(packet->buffer);
     1125                packet->buffer = 0;
     1126        }
     1127
     1128        if (dag_set_stream_poll(FORMAT_DATA->device->fd, FORMAT_DATA->dagstream,
     1129                                sizeof(dag_record_t), &maxwait,
     1130                                &pollwait) == -1) {
    11061131                trace_set_err(libtrace, errno, "dag_set_stream_poll");
    11071132                return -1;
     
    11251150        /* Prepare the libtrace packet */
    11261151        if (dag_prepare_packet(libtrace, packet, erfptr, TRACE_RT_DATA_ERF,
    1127                                 flags))
     1152                               flags))
    11281153                return -1;
    11291154
    11301155        /* Update the DUCK timer */
    11311156        tv = trace_get_timeval(packet);
    1132         DUCK.last_pkt = tv.tv_sec;
     1157        DUCK.last_pkt = tv.tv_sec;
    11331158
    11341159        return packet->payload ? htons(erfptr->rlen) :
    1135                                 erf_get_framing_length(packet);
     1160                erf_get_framing_length(packet);
    11361161}
    11371162
     
    11411166 */
    11421167static libtrace_eventobj_t trace_event_dag(libtrace_t *libtrace,
    1143                                         libtrace_packet_t *packet) {
    1144         libtrace_eventobj_t event = {0,0,0.0,0};
     1168                                           libtrace_packet_t *packet)
     1169{
     1170        libtrace_eventobj_t event = {0,0,0.0,0};
    11451171        dag_record_t *erfptr = NULL;
    11461172        int numbytes;
    11471173        uint32_t flags = 0;
    11481174        struct timeval minwait;
    1149        
     1175
    11501176        minwait.tv_sec = 0;
    11511177        minwait.tv_usec = 10000;
    1152        
    1153         if (dag_set_stream_poll(FORMAT_DATA->device->fd,
    1154                         FORMAT_DATA->dagstream, 0, &minwait,
    1155                         &minwait) == -1)
    1156         {
     1178
     1179        if (dag_set_stream_poll(FORMAT_DATA->device->fd,
     1180                                FORMAT_DATA->dagstream, 0, &minwait,
     1181                                &minwait) == -1) {
    11571182                trace_set_err(libtrace, errno, "dag_set_stream_poll");
    11581183                event.type = TRACE_EVENT_TERMINATE;
     
    11631188                erfptr = NULL;
    11641189                numbytes = 0;
    1165        
     1190
    11661191                /* Need to call dag_available so that the top pointer will get
    11671192                 * updated, otherwise we'll never see any data! */
    11681193                numbytes = dag_available(libtrace);
    11691194
    1170                 /* May as well not bother calling dag_get_record if 
     1195                /* May as well not bother calling dag_get_record if
    11711196                 * dag_available suggests that there's no data */
    11721197                if (numbytes != 0)
     
    11761201                        if (libtrace_halt) {
    11771202                                event.type = TRACE_EVENT_TERMINATE;
    1178                         } else {                       
     1203                        } else {
    11791204                                event.type = TRACE_EVENT_SLEEP;
    11801205                                event.seconds = 0.0001;
     
    11821207                        break;
    11831208                }
    1184                 if (dag_prepare_packet(libtrace, packet, erfptr, 
    1185                                         TRACE_RT_DATA_ERF, flags)) {
     1209                if (dag_prepare_packet(libtrace, packet, erfptr,
     1210                                       TRACE_RT_DATA_ERF, flags)) {
    11861211                        event.type = TRACE_EVENT_TERMINATE;
    11871212                        break;
     
    11891214
    11901215
    1191                 event.size = trace_get_capture_length(packet) + 
    1192                                 trace_get_framing_length(packet);
    1193                
     1216                event.size = trace_get_capture_length(packet) +
     1217                        trace_get_framing_length(packet);
     1218
    11941219                /* XXX trace_read_packet() normally applies the following
    11951220                 * config options for us, but this function is called via
     
    11971222
    11981223                if (libtrace->filter) {
    1199                         int filtret = trace_apply_filter(libtrace->filter, 
    1200                                         packet);
     1224                        int filtret = trace_apply_filter(libtrace->filter,
     1225                                                         packet);
    12011226                        if (filtret == -1) {
    12021227                                trace_set_err(libtrace, TRACE_ERR_BAD_FILTER,
    1203                                                 "Bad BPF Filter");
     1228                                              "Bad BPF Filter");
    12041229                                event.type = TRACE_EVENT_TERMINATE;
    12051230                                break;
     
    12121237                                 * a sleep event in this case, like we used to
    12131238                                 * do! */
    1214                                 libtrace->filtered_packets ++;
     1239                                libtrace->filtered_packets ++;
    12151240                                trace_clear_cache(packet);
    12161241                                continue;
    12171242                        }
    1218                                
     1243
    12191244                        event.type = TRACE_EVENT_PACKET;
    12201245                } else {
     
    12251250                        trace_set_capture_length(packet, libtrace->snaplen);
    12261251                }
    1227                 libtrace->accepted_packets ++;
     1252                libtrace->accepted_packets ++;
    12281253                break;
    1229         } while (1);
     1254        } while(1);
    12301255
    12311256        return event;
     
    12331258
    12341259/* Gets the number of dropped packets */
    1235 static uint64_t dag_get_dropped_packets(libtrace_t *trace) {
     1260static uint64_t dag_get_dropped_packets(libtrace_t *trace)
     1261{
    12361262        uint64_t sum = 0;
    12371263        int i, tot;
    12381264
    12391265        if (trace->format_data == NULL)
    1240                 return (uint64_t)-1;
     1266                return (uint64_t) - 1;
    12411267
    12421268        if (DATA(trace)->per_thread) {
     
    12451271                for (i = 0; i < tot; i++) {
    12461272                        printf("t%d: drops %" PRIu64 "\n",
    1247                                    DATA(trace)->per_thread[i].drops);
     1273                               DATA(trace)->per_thread[i].drops);
    12481274                        sum += DATA(trace)->per_thread[i].drops;
    12491275                }
     
    12571283/* Prints some semi-useful help text about the DAG format module */
    12581284static void dag_help(void) {
    1259         printf("dag format module: $Revision: 1755 $\n");
    1260         printf("Supported input URIs:\n");
    1261         printf("\tdag:/dev/dagn\n");
    1262         printf("\n");
    1263         printf("\te.g.: dag:/dev/dag0\n");
    1264         printf("\n");
    1265         printf("Supported output URIs:\n");
    1266         printf("\tnone\n");
    1267         printf("\n");
    1268 }
    1269 
    1270 static int dag_pstart_input(libtrace_t *libtrace) {
     1285        printf("dag format module: $Revision: 1755 $\n");
     1286        printf("Supported input URIs:\n");
     1287        printf("\tdag:/dev/dagn\n");
     1288        printf("\n");
     1289        printf("\te.g.: dag:/dev/dag0\n");
     1290        printf("\n");
     1291        printf("Supported output URIs:\n");
     1292        printf("\tnone\n");
     1293        printf("\n");
     1294}
     1295
     1296static int dag_pstart_input(libtrace_t *libtrace)
     1297{
    12711298        char *scan, *tok;
    12721299        uint16_t stream_count = 0, max_streams;
     
    12761303        int iserror = 0;
    12771304
    1278         /* Check we aren't trying to create more threads than the DAG card can 
     1305        /* Check we aren't trying to create more threads than the DAG card can
    12791306         * handle */
    12801307        max_streams = dag_rx_get_stream_count(FORMAT_DATA->device->fd);
    12811308        if (libtrace->perpkt_thread_count > max_streams) {
    1282                 trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT, "trying to create too "
    1283                                           "many threads (max is %u)", max_streams);
     1309                trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT,
     1310                              "trying to create too many threads (max is %u)",
     1311                              max_streams);
    12841312                iserror = 1;
    12851313                goto cleanup;
     
    12881316        /* Create the thread structures */
    12891317        per_thread = calloc(libtrace->perpkt_thread_count,
    1290                                                                         sizeof(struct dag_per_thread_t));
     1318                            sizeof(struct dag_per_thread_t));
    12911319        FORMAT_DATA->per_thread = per_thread;
    12921320
    12931321        /* Get the stream names from the uri */
    12941322        if ((scan = strchr(libtrace->uridata, ',')) == NULL) {
    1295                 trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT, "format uri doesn't "
    1296                                           "specify the DAG streams");
     1323                trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT,
     1324                              "format uri doesn't specify the DAG streams");
    12971325                iserror = 1;
    12981326                goto cleanup;
     
    13001328
    13011329        scan++;
    1302  
     1330
    13031331        tok = strtok(scan, ",");
    13041332        while (tok != NULL) {
    13051333                /* Ensure we haven't specified too many streams */
    13061334                if (stream_count >= libtrace->perpkt_thread_count) {
    1307                         trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT, "format uri specifies too "
    1308                                           "many streams. Max is %u", max_streams);
     1335                        trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT,
     1336                                      "format uri specifies too many streams. "
     1337                                      "Max is %u", max_streams);
    13091338                        iserror = 1;
    13101339                        goto cleanup;
     
    13221351                /* Free the per_thread memory */
    13231352                free(per_thread);
    1324                
    13251353                return -1;
    13261354        } else {
     
    13321360
    13331361/* TODO: Fold this into dag_available */
    1334 static int dag_pavailable(libtrace_t *libtrace, libtrace_thread_t *t) {
     1362static int dag_pavailable(libtrace_t *libtrace, libtrace_thread_t *t)
     1363{
    13351364        uint32_t diff = PERPKT_DATA(t)->top - PERPKT_DATA(t)->bottom;
    13361365
     
    13381367         * dag_advance_stream, then we should call it again to allow the
    13391368         * space occupied by that 4MB to be released */
    1340         if (diff >= dag_record_size && PERPKT_DATA(t)->processed < 4 * 1024 * 1024)
     1369        if (diff >= dag_record_size && PERPKT_DATA(t)->processed <
     1370            4*1024*1024)
    13411371                return diff;
    13421372
    13431373        /* Update top and bottom pointers */
    13441374        PERPKT_DATA(t)->top = dag_advance_stream(PERPKT_DATA(t)->device->fd,
    1345                                                                                         PERPKT_DATA(t)->stream,
    1346                                                                                         &(PERPKT_DATA(t)->bottom));
     1375                                                PERPKT_DATA(t)->stream,
     1376                                                &(PERPKT_DATA(t)->bottom));
    13471377
    13481378        if (PERPKT_DATA(t)->top == NULL) {
     
    13581388/* TODO: Fold this into dag_get_record */
    13591389static dag_record_t *dag_pget_record(libtrace_t *libtrace,
    1360                                                                          libtrace_thread_t *t) {
     1390                                     libtrace_thread_t *t)
     1391{
    13611392        dag_record_t *erfptr = NULL;
    13621393        uint16_t size;
     
    13751406        PERPKT_DATA(t)->bottom += size;
    13761407        PERPKT_DATA(t)->processed += size;
    1377        
     1408
    13781409        return erfptr;
    13791410}
    13801411
    13811412static int dag_pread_packet(libtrace_t *libtrace, libtrace_thread_t *t,
    1382                                                         libtrace_packet_t *packet) {
     1413                            libtrace_packet_t *packet)
     1414{
    13831415        dag_record_t *erfptr = NULL;
    13841416        int numbytes = 0;
     
    14041436
    14051437        /* Configure DAG card stream polling */
    1406         if (dag_set_stream_poll(PERPKT_DATA(t)->device->fd, PERPKT_DATA(t)->stream,
    1407                                                         sizeof(dag_record_t), &maxwait, &pollwait) < 0) {
     1438        if (dag_set_stream_poll(PERPKT_DATA(t)->device->fd,
     1439                                PERPKT_DATA(t)->stream, sizeof(dag_record_t),
     1440                                &maxwait, &pollwait) < 0) {
    14081441                trace_set_err(libtrace, errno, "dag_set_stream_poll");
    14091442                return -1;
     
    14191452                                return 0;
    14201453
    1421                         /* Check message queue to see if we should abort early */
     1454                        /* Check message queue to see if we should
     1455                         * abort early */
    14221456                        if (libtrace_message_queue_count(&t->messages) > 0)
    14231457                                return -2;
     
    14321466        /* Prepare the libtrace packet */
    14331467        if (dag_prepare_packet(libtrace, packet, erfptr, TRACE_RT_DATA_ERF,
    1434                                                    flags))
     1468                               flags))
    14351469                return -1;
    14361470
     
    14411475}
    14421476
    1443 static int dag_ppause_input(libtrace_t *libtrace) {
     1477static int dag_ppause_input(libtrace_t *libtrace)
     1478{
    14441479        int i, tot = libtrace->perpkt_thread_count;
    14451480        struct dag_per_thread_t *t_data;
     
    14511486
    14521487                if (dag_stop_stream(t_data->device->fd,
    1453                                                         t_data->stream) < 0) {
    1454                         trace_set_err(libtrace, errno, "can't stop DAG stream #%u",
    1455                                                   t_data->stream);
     1488                                    t_data->stream) < 0) {
     1489                        trace_set_err(libtrace, errno,
     1490                                      "can't stop DAG stream #%u",
     1491                                      t_data->stream);
    14561492                        return -1;
    14571493                }
    14581494
    14591495                if (dag_detach_stream(t_data->device->fd,
    1460                                                           t_data->stream) < 0) {
    1461                         trace_set_err(libtrace, errno, "can't detach DAG stream #%u",
    1462                                                   t_data->stream);
     1496                                      t_data->stream) < 0) {
     1497                        trace_set_err(libtrace, errno,
     1498                                      "can't detach DAG stream #%u",
     1499                                      t_data->stream);
    14631500                        return -1;
    14641501                }
     
    14731510
    14741511static int dag_pconfig_input(libtrace_t *libtrace,
    1475                                                          trace_parallel_option_t option, void *value) {
    1476 
     1512                             trace_parallel_option_t option, void *value)
     1513{
    14771514        /* We don't support any of these! Normally you configure the DAG card
    14781515         * externally. */
     
    14931530
    14941531static int dag_pregister_thread(libtrace_t *libtrace, libtrace_thread_t *t,
    1495                                                                 bool reader) {
     1532                                bool reader)
     1533{
    14961534        /* XXX: This function gets run sequentially for all
    14971535         * threads. Should investigate making it parallel as draining the
     
    14991537         */
    15001538        uint8_t *top, *bottom;
    1501         uint8_t diff = 0; /* XXX: Investigate this type, as I would assume the value
    1502                                            * could be larger than 255 */
     1539        /* XXX: Investigate this type, as I would assume the value
     1540         * could be larger than 255 */
     1541        uint8_t diff = 0;
    15031542        struct timeval zero, nopoll;
    15041543
     
    15131552                if (t->type == THREAD_PERPKT) {
    15141553                        /* Pass the per thread data to the thread */
    1515                         t->format_data = &FORMAT_DATA->per_thread[t->perpkt_num];
     1554                        t->format_data =
     1555                                &FORMAT_DATA->per_thread[t->perpkt_num];
    15161556
    15171557                        /* Attach and start the DAG stream */
    1518                         printf("t%u: starting and attaching stream #%u\n", t->perpkt_num,
    1519                                   PERPKT_DATA(t)->stream);
     1558                        printf("t%u: starting and attaching stream #%u\n",
     1559                               t->perpkt_num, PERPKT_DATA(t)->stream);
    15201560                        if (dag_attach_stream(PERPKT_DATA(t)->device->fd,
    1521                                                                   PERPKT_DATA(t)->stream, 0, 0) < 0) {
    1522                                 trace_set_err(libtrace, errno, "can't attach DAG stream #%u",
    1523                                                           PERPKT_DATA(t)->stream);
     1561                                              PERPKT_DATA(t)->stream, 0,
     1562                                              0) < 0) {
     1563                                trace_set_err(libtrace, errno,
     1564                                              "can't attach DAG stream #%u",
     1565                                              PERPKT_DATA(t)->stream);
    15241566                                return -1;
    15251567                        }
    15261568                        if (dag_start_stream(PERPKT_DATA(t)->device->fd,
    1527                                                                  PERPKT_DATA(t)->stream) < 0) {
    1528                                 trace_set_err(libtrace, errno, "can't start DAG stream #%u",
    1529                                                           PERPKT_DATA(t)->stream);
     1569                                             PERPKT_DATA(t)->stream) < 0) {
     1570                                trace_set_err(libtrace, errno,
     1571                                              "can't start DAG stream #%u",
     1572                                              PERPKT_DATA(t)->stream);
    15301573                                return -1;
    15311574                        }
     
    15331576                        /* Ensure that dag_advance_stream will return without blocking */
    15341577                        if(dag_set_stream_poll(PERPKT_DATA(t)->device->fd,
    1535                                                                    PERPKT_DATA(t)->stream, 0, &zero,
    1536                                                                    &nopoll) < 0) {
    1537                                 trace_set_err(libtrace, errno, "dag_set_stream_poll failed!");
     1578                                               PERPKT_DATA(t)->stream, 0, &zero,
     1579                                               &nopoll) < 0) {
     1580                                trace_set_err(libtrace, errno,
     1581                                              "dag_set_stream_poll failed!");
    15381582                                return -1;
    15391583                        }
     
    15411585                        /* Clear all the data from the memory hole */
    15421586                        do {
    1543                                 top = dag_advance_stream(PERPKT_DATA(t)->device->fd,
    1544                                                                                  PERPKT_DATA(t)->stream,
    1545                                                                                  &bottom);
     1587                                top = dag_advance_stream(PERPKT_DATA(t)->
     1588                                                         device->fd,
     1589                                                         PERPKT_DATA(t)->stream,
     1590                                                         &bottom);
    15461591
    15471592                                assert(top && bottom);
     
    15661611
    15671612static struct libtrace_format_t dag = {
    1568         "dag",
    1569         "$Id$",
    1570         TRACE_FORMAT_ERF,
     1613        "dag",
     1614        "$Id$",
     1615        TRACE_FORMAT_ERF,
    15711616        dag_probe_filename,             /* probe filename */
    15721617        NULL,                           /* probe magic */
    1573         dag_init_input,                 /* init_input */
    1574         dag_config_input,               /* config_input */
    1575         dag_start_input,                /* start_input */
    1576         dag_pause_input,                /* pause_input */
     1618        dag_init_input,                 /* init_input */
     1619        dag_config_input,               /* config_input */
     1620        dag_start_input,                /* start_input */
     1621        dag_pause_input,                /* pause_input */
    15771622        dag_init_output,                /* init_output */
    1578         NULL,                           /* config_output */
     1623        NULL,                           /* config_output */
    15791624        dag_start_output,               /* start_output */
    1580         dag_fin_input,                  /* fin_input */
     1625        dag_fin_input,                  /* fin_input */
    15811626        dag_fin_output,                 /* fin_output */
    1582         dag_read_packet,                /* read_packet */
    1583         dag_prepare_packet,             /* prepare_packet */
     1627        dag_read_packet,                /* read_packet */
     1628        dag_prepare_packet,             /* prepare_packet */
    15841629        NULL,                           /* fin_packet */
    15851630        dag_write_packet,               /* write_packet */
    1586         erf_get_link_type,              /* get_link_type */
    1587         erf_get_direction,              /* get_direction */
    1588         erf_set_direction,              /* set_direction */
    1589         erf_get_erf_timestamp,          /* get_erf_timestamp */
    1590         NULL,                           /* get_timeval */
    1591         NULL,                           /* get_seconds */
     1631        erf_get_link_type,              /* get_link_type */
     1632        erf_get_direction,              /* get_direction */
     1633        erf_set_direction,              /* set_direction */
     1634        erf_get_erf_timestamp,          /* get_erf_timestamp */
     1635        NULL,                           /* get_timeval */
     1636        NULL,                           /* get_seconds */
    15921637        NULL,                           /* get_timespec */
    1593         NULL,                           /* seek_erf */
    1594         NULL,                           /* seek_timeval */
    1595         NULL,                           /* seek_seconds */
    1596         erf_get_capture_length,         /* get_capture_length */
    1597         erf_get_wire_length,            /* get_wire_length */
    1598         erf_get_framing_length,         /* get_framing_length */
    1599         erf_set_capture_length,         /* set_capture_length */
     1638        NULL,                           /* seek_erf */
     1639        NULL,                           /* seek_timeval */
     1640        NULL,                           /* seek_seconds */
     1641        erf_get_capture_length,         /* get_capture_length */
     1642        erf_get_wire_length,            /* get_wire_length */
     1643        erf_get_framing_length,         /* get_framing_length */
     1644        erf_set_capture_length,         /* set_capture_length */
    16001645        NULL,                           /* get_received_packets */
    16011646        NULL,                           /* get_filtered_packets */
    16021647        dag_get_dropped_packets,        /* get_dropped_packets */
    16031648        NULL,                           /* get_captured_packets */
    1604         NULL,                           /* get_fd */
    1605         trace_event_dag,                /* trace_event */
    1606         dag_help,                       /* help */
    1607         NULL,                            /* next pointer */
     1649        NULL,                           /* get_fd */
     1650        trace_event_dag,                /* trace_event */
     1651        dag_help,                       /* help */
     1652        NULL,                            /* next pointer */
    16081653                {true, 0}, /* live packet capture, thread limit TBD */
    16091654                dag_pstart_input,
     
    16161661};
    16171662
    1618 void dag_constructor(void) {
     1663void dag_constructor(void)
     1664{
    16191665        register_format(&dag);
    16201666}
Note: See TracChangeset for help on using the changeset viewer.