Changeset 51d1f64 for lib

Timestamp:

09/08/14 14:35:41 (7 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:

• lib/format_dag25.c (modified) (10 diffs)

lib/format_dag25.c

@@ -586 +586 @@
 
         zero.tv_sec = 0;
-        zero.tv_usec = 0;
+        zero.tv_usec = 10000;
         nopoll = zero;
 
@@ -992 +992 @@
                 /* Flags. Can't do this */
                 memset(&erfhdr.flags,1,sizeof(erfhdr.flags));
-                if (trace_get_direction(packet)!=~0U)
+                if (trace_get_direction(packet)!=(int)~0U)
                         erfhdr.flags.iface = trace_get_direction(packet);
 
@@ -1035 +1035 @@
         int numbytes = 0;
         uint32_t flags = 0;
+        struct timeval maxwait;
+        struct timeval pollwait;
+
+        pollwait.tv_sec = 0;
+        pollwait.tv_usec = 10000;
+        maxwait.tv_sec = 0;
+        maxwait.tv_usec = 250000;
 
         /* Check if we're due for a DUCK report */
@@ -1057 +1064 @@
                 packet->buffer = 0;
         }
+        
+        if (dag_set_stream_poll(FORMAT_DATA->device->fd, 
+                        FORMAT_DATA->dagstream, sizeof(dag_record_t), &maxwait, 
+                        &pollwait) == -1)
+        {
+                trace_set_err(libtrace, errno, "dag_set_stream_poll");
+                return -1;
+        }
+
 
         /* Grab a full ERF record */
@@ -1063 +1079 @@
                 if (numbytes < 0)
                         return numbytes;
-                if (numbytes < dag_record_size)
+                if (numbytes < dag_record_size) {
+                        if (libtrace_halt)
+                                return 0;
                         /* Block until we see a packet */
                         continue;
+                }
                 erfptr = dag_get_record(libtrace);
         } while (erfptr == NULL);
@@ -1086 +1105 @@
  * return a SLEEP event (as we cannot select on the DAG file descriptor).
  */
-static libtrace_eventobj_t trace_event_dag(libtrace_t *trace,
+static libtrace_eventobj_t trace_event_dag(libtrace_t *libtrace,
                                         libtrace_packet_t *packet) {
         libtrace_eventobj_t event = {0,0,0.0,0};
@@ -1092 +1111 @@
         int numbytes;
         uint32_t flags = 0;
+        struct timeval minwait;
+        
+        minwait.tv_sec = 0;
+        minwait.tv_usec = 10000;
+        
+        if (dag_set_stream_poll(FORMAT_DATA->device->fd, 
+                        FORMAT_DATA->dagstream, 0, &minwait, 
+                        &minwait) == -1)
+        {
+                trace_set_err(libtrace, errno, "dag_set_stream_poll");
+                event.type = TRACE_EVENT_TERMINATE;
+                return event;
+        }
 
         do {
@@ -1099 +1131 @@
                 /* Need to call dag_available so that the top pointer will get
                  * updated, otherwise we'll never see any data! */
-                numbytes = dag_available(trace);
+                numbytes = dag_available(libtrace);
 
                 /* May as well not bother calling dag_get_record if 
                  * dag_available suggests that there's no data */
                 if (numbytes != 0)
-                        erfptr = dag_get_record(trace);
+                        erfptr = dag_get_record(libtrace);
                 if (erfptr == NULL) {
                         /* No packet available - sleep for a very short time */
-                        event.type = TRACE_EVENT_SLEEP;
-                        event.seconds = 0.0001;
+                        if (libtrace_halt) {
+                                event.type = TRACE_EVENT_TERMINATE;
+                        } else {                        
+                                event.type = TRACE_EVENT_SLEEP;
+                                event.seconds = 0.0001;
+                        }
                         break;
                 }
-                if (dag_prepare_packet(trace, packet, erfptr, 
+                if (dag_prepare_packet(libtrace, packet, erfptr, 
                                         TRACE_RT_DATA_ERF, flags)) {
                         event.type = TRACE_EVENT_TERMINATE;
@@ -1125 +1161 @@
                  * trace_event() so we have to do it ourselves */
 
-                if (trace->filter) {
-                        if (trace_apply_filter(trace->filter, packet)) {
-                                event.type = TRACE_EVENT_PACKET;
-                        } else {
+                if (libtrace->filter) {
+                        int filtret = trace_apply_filter(libtrace->filter, 
+                                        packet);
+                        if (filtret == -1) {
+                                trace_set_err(libtrace, TRACE_ERR_BAD_FILTER,
+                                                "Bad BPF Filter");
+                                event.type = TRACE_EVENT_TERMINATE;
+                                break;
+                        }
+
+                        if (filtret == 0) {
                                 /* This packet isn't useful so we want to
                                  * immediately see if there is another suitable
@@ -1134 +1177 @@
                                  * a sleep event in this case, like we used to
                                  * do! */
-                                trace->filtered_packets ++;
+                                libtrace->filtered_packets ++;
                                 trace_clear_cache(packet);
                                 continue;
                         }
+                                
+                        event.type = TRACE_EVENT_PACKET;
                 } else {
                         event.type = TRACE_EVENT_PACKET;
                 }
 
-                if (trace->snaplen > 0) {
-                        trace_set_capture_length(packet, trace->snaplen);
+                if (libtrace->snaplen > 0) {
+                        trace_set_capture_length(packet, libtrace->snaplen);
                 }
-                trace->accepted_packets ++;
+                libtrace->accepted_packets ++;
                 break;
         } while (1);