Changeset 51d1f64


Ignore:
Timestamp:
09/08/14 14:35:41 (6 years ago)
Author:
Shane Alcock <salcock@…>
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:
25110ee
Parents:
5d8457d
Message:

Fixed interrupt and bogus filter bugs for dag:

trace_interrupt now works correctly for dag: when using both
trace_read_packet() and trace_event().

Stopped trace_read_packet from consuming vast quantities of CPU
when blocking waiting for a packet -- now libdag handles the waiting
for us.

Supplying an invalid filter will now cause an error to be reported rather
than accepting the first packet.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_dag25.c

    rc70f59f r51d1f64  
    586586
    587587        zero.tv_sec = 0;
    588         zero.tv_usec = 0;
     588        zero.tv_usec = 10000;
    589589        nopoll = zero;
    590590
     
    992992                /* Flags. Can't do this */
    993993                memset(&erfhdr.flags,1,sizeof(erfhdr.flags));
    994                 if (trace_get_direction(packet)!=~0U)
     994                if (trace_get_direction(packet)!=(int)~0U)
    995995                        erfhdr.flags.iface = trace_get_direction(packet);
    996996
     
    10351035        int numbytes = 0;
    10361036        uint32_t flags = 0;
     1037        struct timeval maxwait;
     1038        struct timeval pollwait;
     1039
     1040        pollwait.tv_sec = 0;
     1041        pollwait.tv_usec = 10000;
     1042        maxwait.tv_sec = 0;
     1043        maxwait.tv_usec = 250000;
    10371044
    10381045        /* Check if we're due for a DUCK report */
     
    10571064                packet->buffer = 0;
    10581065        }
     1066       
     1067        if (dag_set_stream_poll(FORMAT_DATA->device->fd,
     1068                        FORMAT_DATA->dagstream, sizeof(dag_record_t), &maxwait,
     1069                        &pollwait) == -1)
     1070        {
     1071                trace_set_err(libtrace, errno, "dag_set_stream_poll");
     1072                return -1;
     1073        }
     1074
    10591075
    10601076        /* Grab a full ERF record */
     
    10631079                if (numbytes < 0)
    10641080                        return numbytes;
    1065                 if (numbytes < dag_record_size)
     1081                if (numbytes < dag_record_size) {
     1082                        if (libtrace_halt)
     1083                                return 0;
    10661084                        /* Block until we see a packet */
    10671085                        continue;
     1086                }
    10681087                erfptr = dag_get_record(libtrace);
    10691088        } while (erfptr == NULL);
     
    10861105 * return a SLEEP event (as we cannot select on the DAG file descriptor).
    10871106 */
    1088 static libtrace_eventobj_t trace_event_dag(libtrace_t *trace,
     1107static libtrace_eventobj_t trace_event_dag(libtrace_t *libtrace,
    10891108                                        libtrace_packet_t *packet) {
    10901109        libtrace_eventobj_t event = {0,0,0.0,0};
     
    10921111        int numbytes;
    10931112        uint32_t flags = 0;
     1113        struct timeval minwait;
     1114       
     1115        minwait.tv_sec = 0;
     1116        minwait.tv_usec = 10000;
     1117       
     1118        if (dag_set_stream_poll(FORMAT_DATA->device->fd,
     1119                        FORMAT_DATA->dagstream, 0, &minwait,
     1120                        &minwait) == -1)
     1121        {
     1122                trace_set_err(libtrace, errno, "dag_set_stream_poll");
     1123                event.type = TRACE_EVENT_TERMINATE;
     1124                return event;
     1125        }
    10941126
    10951127        do {
     
    10991131                /* Need to call dag_available so that the top pointer will get
    11001132                 * updated, otherwise we'll never see any data! */
    1101                 numbytes = dag_available(trace);
     1133                numbytes = dag_available(libtrace);
    11021134
    11031135                /* May as well not bother calling dag_get_record if
    11041136                 * dag_available suggests that there's no data */
    11051137                if (numbytes != 0)
    1106                         erfptr = dag_get_record(trace);
     1138                        erfptr = dag_get_record(libtrace);
    11071139                if (erfptr == NULL) {
    11081140                        /* No packet available - sleep for a very short time */
    1109                         event.type = TRACE_EVENT_SLEEP;
    1110                         event.seconds = 0.0001;
     1141                        if (libtrace_halt) {
     1142                                event.type = TRACE_EVENT_TERMINATE;
     1143                        } else {                       
     1144                                event.type = TRACE_EVENT_SLEEP;
     1145                                event.seconds = 0.0001;
     1146                        }
    11111147                        break;
    11121148                }
    1113                 if (dag_prepare_packet(trace, packet, erfptr,
     1149                if (dag_prepare_packet(libtrace, packet, erfptr,
    11141150                                        TRACE_RT_DATA_ERF, flags)) {
    11151151                        event.type = TRACE_EVENT_TERMINATE;
     
    11251161                 * trace_event() so we have to do it ourselves */
    11261162
    1127                 if (trace->filter) {
    1128                         if (trace_apply_filter(trace->filter, packet)) {
    1129                                 event.type = TRACE_EVENT_PACKET;
    1130                         } else {
     1163                if (libtrace->filter) {
     1164                        int filtret = trace_apply_filter(libtrace->filter,
     1165                                        packet);
     1166                        if (filtret == -1) {
     1167                                trace_set_err(libtrace, TRACE_ERR_BAD_FILTER,
     1168                                                "Bad BPF Filter");
     1169                                event.type = TRACE_EVENT_TERMINATE;
     1170                                break;
     1171                        }
     1172
     1173                        if (filtret == 0) {
    11311174                                /* This packet isn't useful so we want to
    11321175                                 * immediately see if there is another suitable
     
    11341177                                 * a sleep event in this case, like we used to
    11351178                                 * do! */
    1136                                 trace->filtered_packets ++;
     1179                                libtrace->filtered_packets ++;
    11371180                                trace_clear_cache(packet);
    11381181                                continue;
    11391182                        }
     1183                               
     1184                        event.type = TRACE_EVENT_PACKET;
    11401185                } else {
    11411186                        event.type = TRACE_EVENT_PACKET;
    11421187                }
    11431188
    1144                 if (trace->snaplen > 0) {
    1145                         trace_set_capture_length(packet, trace->snaplen);
     1189                if (libtrace->snaplen > 0) {
     1190                        trace_set_capture_length(packet, libtrace->snaplen);
    11461191                }
    1147                 trace->accepted_packets ++;
     1192                libtrace->accepted_packets ++;
    11481193                break;
    11491194        } while (1);
Note: See TracChangeset for help on using the changeset viewer.