Changeset eb27e8e

Timestamp:

12/18/06 16:24:42 (16 years ago)

Author:

Shane Alcock <salcock@…>

Branches:

4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, getfragoff, help, libtrace4, master, ndag_format, pfring, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes

Children:

8cecc7c

Parents:

92a37b0

Message:

Completely reworked dag_read_packet to deal with DAG2.4/DAG2.5 differences in a slightly tidier fashion. Also stopped using the get_next_record function, although it seems fairly useful.

File:

• lib/format_erf.c (modified) (9 diffs)

lib/format_erf.c

@@ -108 +108 @@
         struct {
                 void *buf; 
-                unsigned bottom;
-                unsigned top;
-                unsigned diff;
-                unsigned curr;
-                unsigned offset;
+                uint32_t diff;
+                uint32_t offset;
+#ifdef DAG_VERSION_2_4
+                uint32_t bottom;
+                uint32_t top;
+#else
+                uint8_t *bottom;
+                uint8_t *top;
                 unsigned int dagstream;
+#endif
         } dag;
 #endif
@@ -164 +168 @@
                 return -1;
         } 
-
+#ifdef DAG_VERSION_2_4
+        DAG.top = 0;
+        DAG.bottom = 0;
+#else
+        DAG.top = NULL;
+        DAG.bottom = NULL;
         DAG.dagstream = 0;
-        
+#endif  
         if (S_ISCHR(buf.st_mode)) {
                 /* DEVICE */
@@ -519 +528 @@
 #endif
 
-static int dag_read(libtrace_t *libtrace, int block_flag) {
+static int dag_available(libtrace_t *libtrace) {
 
         if (DAG.diff != 0) 
@@ -525 +534 @@
 
         DAG.bottom = DAG.top;
-
+#ifdef DAG_VERSION_2_4
         DAG.top = dag_offset(
                         INPUT.fd,
                         &(DAG.bottom),
-                        block_flag);
-
+                        DAGF_NONBLOCK);
+
+#else
+        DAG.top = dag_advance_stream(INPUT.fd, DAG.dagstream, &(DAG.bottom));
+#endif
         DAG.diff = DAG.top - DAG.bottom;
 
@@ -537 +549 @@
 }
 
-/* FIXME: dag_read_packet shouldn't update the pointers, dag_fin_packet
- * should do that.
- */
-static int dag_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
-        int numbytes;
-        int size;
-        struct timeval tv;
+dag_record_t *dag_get_record(libtrace_t *libtrace) {
         dag_record_t *erfptr;
-        char *next_record = NULL;       
-
-        if (DUCK.last_pkt - DUCK.last_duck > DUCK.duck_freq && 
-                        DUCK.duck_freq != 0) {
-                size = dag_get_duckinfo(libtrace, packet);
-                DUCK.last_duck = DUCK.last_pkt;
-                if (size != 0) {
-                        return size;
-                }
-                /* No DUCK support, so don't waste our time anymore */
-                DUCK.duck_freq = 0;
-        }
-        
-        if (packet->buf_control == TRACE_CTRL_PACKET) {
-                packet->buf_control = TRACE_CTRL_EXTERNAL;
-                free(packet->buffer);
-                packet->buffer = 0;
-        }
-        
-        packet->type = TRACE_RT_DATA_ERF;
+        uint16_t size;
 #ifdef DAG_VERSION_2_4
-        if ((numbytes = dag_read(libtrace,0)) < 0) 
-                return numbytes;
-        assert(numbytes>0);
-
-        /*DAG always gives us whole packets */
-        erfptr = (dag_record_t *) ((char *)DAG.buf + 
-                        (DAG.bottom + DAG.offset));
+        erfptr = (dag_record_t *) ((char *)DAG.buf + (DAG.bottom + DAG.offset));
 #else
-        next_record = (char *)dag_rx_stream_next_record(INPUT.fd, 0);
-        erfptr = (dag_record_t *)next_record;
+        erfptr = (dag_record_t *) DAG.bottom;   
 #endif
         size = ntohs(erfptr->rlen);
         assert( size >= dag_record_size );
-        assert( size < LIBTRACE_PACKET_BUFSIZE);
-        
+        DAG.offset += size;
+        DAG.diff -= size;
+        return erfptr;
+}
+
+void dag_form_packet(dag_record_t *erfptr, libtrace_packet_t *packet) {
         packet->buffer = erfptr;
         packet->header = erfptr;
-        if (((dag_record_t *)packet->buffer)->flags.rxerror == 1) {
+        if (erfptr->flags.rxerror == 1) {
                 /* rxerror means the payload is corrupt - drop it
                  * by tweaking rlen */
@@ -593 +577 @@
         }
 
-#ifdef DAG_VERSION_2_4
-        DAG.offset += size;
-        DAG.diff -= size;
-#endif
+}
+
+/* FIXME: dag_read_packet shouldn't update the pointers, dag_fin_packet
+ * should do that.
+ */
+static int dag_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
+        int numbytes;
+        int size = 0;
+        struct timeval tv;
+        dag_record_t *erfptr;
+
+        if (DUCK.last_pkt - DUCK.last_duck > DUCK.duck_freq && 
+                        DUCK.duck_freq != 0) {
+                size = dag_get_duckinfo(libtrace, packet);
+                DUCK.last_duck = DUCK.last_pkt;
+                if (size != 0) {
+                        return size;
+                }
+                /* No DUCK support, so don't waste our time anymore */
+                DUCK.duck_freq = 0;
+        }
+        
+        if (packet->buf_control == TRACE_CTRL_PACKET) {
+                packet->buf_control = TRACE_CTRL_EXTERNAL;
+                free(packet->buffer);
+                packet->buffer = 0;
+        }
+        
+        packet->type = TRACE_RT_DATA_ERF;
+
+        do {
+                numbytes = dag_available(libtrace);
+                if (numbytes < 0)
+                        return numbytes;
+        } while (numbytes == 0);
+
+        erfptr = dag_get_record(libtrace);
+        dag_form_packet(erfptr, packet);
+        
         tv = trace_get_timeval(packet);
         DUCK.last_pkt = tv.tv_sec;
-        
-        return packet->payload ? size : erf_get_framing_length(packet);
+        return packet->payload ? ntohs(erfptr->rlen) : erf_get_framing_length(packet);
 }
         
 static int dag_start_input(libtrace_t *libtrace) {
+        struct timeval zero, nopoll;
+        zero.tv_sec = 0;
+        zero.tv_usec = 0;
+        nopoll = zero;
+
 #ifdef DAG_VERSION_2_4
         if(dag_start(INPUT.fd) < 0) {
@@ -619 +642 @@
                 return -1;
         }
+        dag_set_stream_poll(INPUT.fd, DAG.dagstream, 0, &zero, &nopoll);
 #endif
         /* dags appear to have a bug where if you call dag_start after
@@ -624 +648 @@
          * happen.  flush the memory hole 
          */
-        while(dag_read(libtrace,DAGF_NONBLOCK)!=0)
+        while(dag_available(libtrace)!=0)
                 DAG.diff=0;
         return 0;
@@ -903 +927 @@
         }
         
-        data = dag_read(trace, DAGF_NONBLOCK);
+        data = dag_available(trace);
 
         if (data > 0) {
                 event.size = dag_read_packet(trace,packet);
-                DATA(trace)->dag.diff -= event.size;
+                //DATA(trace)->dag.diff -= event.size;
                 if (trace->filter) {
                         if (trace_apply_filter(trace->filter, packet)) {