Changeset 92020b8


Ignore:
Timestamp:
02/19/15 16:37:43 (6 years ago)
Author:
Richard Sanger <rsangerarj@…>
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:
16840ea
Parents:
694823f
Message:

Move DAG device back to the shared trace format data, rather than per stream
Fix minor bug introduced by parallel framework changes, it is now up to
the format to mark a packet against their own trace if its needed during
the read packet function.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_dag25.c

    r5ab626a r92020b8  
    124124/* Data that is stored against each input stream */
    125125struct dag_per_stream_t {
    126         /* DAG device */
    127         struct dag_dev_t *device;
    128126        /* DAG stream number */
    129127        uint16_t dagstream;
     
    160158                libtrace_t *dummy_duck;
    161159        } duck;
    162 
    163         /* String containing the DAG device name */
     160        /* DAG device */
     161        struct dag_dev_t *device;
     162        /* String containing the DAG device name */
    164163        char *device_name;
    165164        /* Boolean flag indicating whether the trace is currently attached */
    166165        int stream_attached;
    167 
    168166        /* Data stored against each DAG input stream */
    169167        libtrace_list_t *per_stream;
     
    445443                FORMAT_DATA_OUT->device_name = strdup(libtrace->uridata);
    446444        } else {
    447                 FORMAT_DATA_OUT->device_name = 
     445                FORMAT_DATA_OUT->device_name =
    448446                                (char *)strndup(libtrace->uridata,
    449447                                (size_t)(scan - libtrace->uridata));
     
    457455        if (dag_device == NULL) {
    458456                /* Device not yet opened - open it ourselves */
    459                 dag_device = dag_open_output_device(libtrace, 
     457                dag_device = dag_open_output_device(libtrace,
    460458                                FORMAT_DATA_OUT->device_name);
    461459        }
     
    522520        }
    523521
    524         FORMAT_DATA_FIRST->device = dag_device;
     522        FORMAT_DATA->device = dag_device;
    525523
    526524        /* See Config_Status_API_Programming_Guide.pdf from the Endace
     
    558556                /* Tell the card our new snap length */
    559557                snprintf(conf_str, 4096, "varlen slen=%i", *(int *)data);
    560                 if (dag_configure(FORMAT_DATA_FIRST->device->fd,
     558                if (dag_configure(FORMAT_DATA->device->fd,
    561559                                  conf_str) != 0) {
    562560                        trace_set_err(libtrace, errno, "Failed to configure "
     
    611609}
    612610
    613 /* Starts a DAG input trace */
    614 static int dag_start_input(libtrace_t *libtrace)
    615 {
     611static int dag_start_input_stream(libtrace_t *libtrace,
     612                                  struct dag_per_stream_t * stream) {
    616613        struct timeval zero, nopoll;
    617614        uint8_t *top, *bottom, *starttop;
     
    623620
    624621        /* Attach and start the DAG stream */
    625         if (dag_attach_stream(FORMAT_DATA_FIRST->device->fd,
    626                               FORMAT_DATA_FIRST->dagstream, 0, 0) < 0) {
    627                 trace_set_err(libtrace, errno, "Cannot attach DAG stream");
    628                 return -1;
    629         }
    630 
    631         if (dag_start_stream(FORMAT_DATA_FIRST->device->fd,
    632                              FORMAT_DATA_FIRST->dagstream) < 0) {
    633                 trace_set_err(libtrace, errno, "Cannot start DAG stream");
     622        if (dag_attach_stream(FORMAT_DATA->device->fd,
     623                              stream->dagstream, 0, 0) < 0) {
     624                trace_set_err(libtrace, errno, "Cannot attach DAG stream #%u",
     625                              stream->dagstream);
     626                return -1;
     627        }
     628
     629        if (dag_start_stream(FORMAT_DATA->device->fd,
     630                             stream->dagstream) < 0) {
     631                trace_set_err(libtrace, errno, "Cannot start DAG stream #%u",
     632                              stream->dagstream);
    634633                return -1;
    635634        }
     
    637636
    638637        /* We don't want the dag card to do any sleeping */
    639         dag_set_stream_poll(FORMAT_DATA_FIRST->device->fd,
    640                             FORMAT_DATA_FIRST->dagstream, 0, &zero,
    641                             &nopoll);
    642 
    643         starttop = dag_advance_stream(FORMAT_DATA_FIRST->device->fd,
    644                                       FORMAT_DATA_FIRST->dagstream,
     638        if (dag_set_stream_poll(FORMAT_DATA->device->fd,
     639                            stream->dagstream, 0, &zero,
     640                            &nopoll) < 0) {
     641                trace_set_err(libtrace, errno,
     642                              "dag_set_stream_poll failed!");
     643                return -1;
     644        }
     645
     646        starttop = dag_advance_stream(FORMAT_DATA->device->fd,
     647                                      stream->dagstream,
    645648                                      &bottom);
    646649
     
    649652        while (starttop - bottom > 0) {
    650653                bottom += (starttop - bottom);
    651                 top = dag_advance_stream(FORMAT_DATA_FIRST->device->fd,
    652                                          FORMAT_DATA_FIRST->dagstream,
     654                top = dag_advance_stream(FORMAT_DATA->device->fd,
     655                                         stream->dagstream,
    653656                                         &bottom);
    654657        }
    655         FORMAT_DATA_FIRST->top = top;
    656         FORMAT_DATA_FIRST->bottom = bottom;
    657         FORMAT_DATA_FIRST->processed = 0;
    658         FORMAT_DATA_FIRST->drops = 0;
     658        stream->top = top;
     659        stream->bottom = bottom;
     660        stream->processed = 0;
     661        stream->drops = 0;
    659662
    660663        return 0;
     664
     665}
     666
     667/* Starts a DAG input trace */
     668static int dag_start_input(libtrace_t *libtrace)
     669{
     670        return dag_start_input_stream(libtrace, FORMAT_DATA_FIRST);
    661671}
    662672
     
    670680        /* Check we aren't trying to create more threads than the DAG card can
    671681         * handle */
    672         max_streams = dag_rx_get_stream_count(FORMAT_DATA_FIRST->device->fd);
     682        max_streams = dag_rx_get_stream_count(FORMAT_DATA->device->fd);
    673683        if (libtrace->perpkt_thread_count > max_streams) {
    674684                trace_set_err(libtrace, TRACE_ERR_BAD_FORMAT,
     
    707717                } else {
    708718                        memset(&stream_data, 0, sizeof(stream_data));
    709                         stream_data.device = FORMAT_DATA_FIRST->device;
    710719                        stream_data.dagstream = (uint16_t)atoi(tok);
    711720                        libtrace_list_push_back(FORMAT_DATA->per_stream,
     
    753762        /* Stop and detach each stream */
    754763        while (tmp != NULL) {
    755                 if (dag_stop_stream(STREAM_DATA(tmp)->device->fd,
     764                if (dag_stop_stream(FORMAT_DATA->device->fd,
    756765                                    STREAM_DATA(tmp)->dagstream) < 0) {
    757766                        trace_set_err(libtrace, errno,
     
    760769                        return -1;
    761770                }
    762                 if (dag_detach_stream(STREAM_DATA(tmp)->device->fd,
     771                if (dag_detach_stream(FORMAT_DATA->device->fd,
    763772                                      STREAM_DATA(tmp)->dagstream) < 0) {
    764773                        trace_set_err(libtrace, errno,
     
    780789static int dag_fin_input(libtrace_t *libtrace)
    781790{
    782         libtrace_list_node_t *tmp = FORMAT_DATA_HEAD;
    783 
    784791        /* Need the lock, since we're going to be handling the device list */
    785792        pthread_mutex_lock(&open_dag_mutex);
     
    788795        if (FORMAT_DATA->stream_attached)
    789796                dag_pause_input(libtrace);
    790 
    791         /* Close any dag devices that have no more references */
    792         while (tmp != NULL) {
    793                 STREAM_DATA(tmp)->device->ref_count--;
    794                 if (STREAM_DATA(tmp)->device->ref_count == 0)
    795                         dag_close_device(STREAM_DATA(tmp)->device);
    796 
    797                 tmp = tmp->next;
    798         }
     797        FORMAT_DATA->device->ref_count--;
     798
     799        /* Close the DAG device if there are no more references to it */
     800        if (FORMAT_DATA->device->ref_count == 0)
     801                dag_close_device(FORMAT_DATA->device);
    799802
    800803        if (DUCK.dummy_duck)
     
    895898        /* No need to check if we can get DUCK or not - we're modern
    896899         * enough so just grab the DUCK info */
    897         if ((ioctl(FORMAT_DATA_FIRST->device->fd, LIBTRACE_DUCK_IOCTL,
     900        if ((ioctl(FORMAT_DATA->device->fd, LIBTRACE_DUCK_IOCTL,
    898901                   (duckinf_t *)packet->payload) < 0)) {
    899902                trace_set_err(libtrace, errno, "Error using DUCK ioctl");
     
    927930
    928931        /* Update the top and bottom pointers */
    929         stream_data->top = dag_advance_stream(stream_data->device->fd,
     932        stream_data->top = dag_advance_stream(FORMAT_DATA->device->fd,
    930933                                              stream_data->dagstream,
    931934                                              &(stream_data->bottom));
     
    12441247        }
    12451248
    1246         if (dag_set_stream_poll(stream_data->device->fd, stream_data->dagstream,
     1249        if (dag_set_stream_poll(FORMAT_DATA->device->fd, stream_data->dagstream,
    12471250                                sizeof(dag_record_t), &maxwait,
    12481251                                &pollwait) == -1) {
     
    12701273        } while (erfptr == NULL);
    12711274
     1275        packet->trace = libtrace;
    12721276        /* Prepare the libtrace packet */
    12731277        if (dag_prepare_packet_real(libtrace, stream_data, packet, erfptr,
     
    13391343        }
    13401344       
    1341         if (dag_set_stream_poll(FORMAT_DATA_FIRST->device->fd,
     1345        if (dag_set_stream_poll(FORMAT_DATA->device->fd,
    13421346                                FORMAT_DATA_FIRST->dagstream, 0, &minwait,
    13431347                                &minwait) == -1) {
     
    14711475}
    14721476
    1473 /* TODO: Should possibly make a more generic dag_start_input, as there's a
    1474  * fair bit of code duplication between that and this */
    14751477static int dag_pregister_thread(libtrace_t *libtrace, libtrace_thread_t *t,
    14761478                                bool reader)
    14771479{
    1478         struct timeval zero, nopoll;
    1479         uint8_t *top, *bottom, *starttop;
    14801480        struct dag_per_stream_t *stream_data;
    1481         top = bottom = NULL;
    1482 
    1483         /* Minimum delay is 10mS */
    1484         zero.tv_sec = 0;
    1485         zero.tv_usec = 10000;
    1486         nopoll = zero;
    14871481
    14881482        if (reader) {
     
    14991493                        printf("t%u: starting and attaching stream #%u\n",
    15001494                               t->perpkt_num, stream_data->dagstream);
    1501                         if (dag_attach_stream(stream_data->device->fd,
    1502                                               stream_data->dagstream, 0,
    1503                                               0) < 0) {
    1504                                 printf("can't attach DAG stream #%u\n",
    1505                                        stream_data->dagstream);
    1506                                 trace_set_err(libtrace, errno,
    1507                                               "can't attach DAG stream #%u",
    1508                                               stream_data->dagstream);
     1495                        if (dag_start_input_stream(libtrace, stream_data) < 0)
    15091496                                return -1;
    1510                         }
    1511                         if (dag_start_stream(stream_data->device->fd,
    1512                                              stream_data->dagstream) < 0) {
    1513                                 trace_set_err(libtrace, errno,
    1514                                               "can't start DAG stream #%u",
    1515                                               stream_data->dagstream);
    1516                                 printf("can't start DAG stream #%u\n",
    1517                                        stream_data->dagstream);
    1518                                 return -1;
    1519                         }
    1520 
    1521                         /* Ensure that dag_advance_stream will return without
    1522                          * blocking */
    1523                         if(dag_set_stream_poll(stream_data->device->fd,
    1524                                                stream_data->dagstream, 0, &zero,
    1525                                                &nopoll) < 0) {
    1526                                 trace_set_err(libtrace, errno,
    1527                                               "dag_set_stream_poll failed!");
    1528                                 return -1;
    1529                         }
    1530 
    1531                         /* Clear all the data from the memory hole */
    1532                         starttop = dag_advance_stream(stream_data->
    1533                                                       device->fd,
    1534                                                       stream_data->dagstream,
    1535                                                       &bottom);
    1536 
    1537                         top = starttop;
    1538                         while (starttop - bottom > 0) {
    1539                                 bottom += (starttop - bottom);
    1540                                 top = dag_advance_stream(stream_data->
    1541                                                          device->fd,
    1542                                                          stream_data->dagstream,
    1543                                                          &bottom);
    1544                         }
    1545                         stream_data->top = top;
    1546                         stream_data->bottom = bottom;
    1547                         stream_data->pkt_count = 0;
    1548                         stream_data->drops = 0;
    15491497                } else {
    15501498                        /* TODO: Figure out why t->type != THREAD_PERPKT in
Note: See TracChangeset for help on using the changeset viewer.