Changeset 52656ed for lib/format_dag25.c

Timestamp:

09/04/07 16:50:19 (14 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:

5798dc6

Parents:

2cf30f6

Message:

• Updated autotools to detect DAG 3.X drivers. The new detection method will also catch DAG 2.5, but this is not a problem because the API is the same so DAG 2.5 and DAG 3 can use the same code within libtrace.
• Changed format_dag25.c to manage the dag stream manually, similar to format_dag24.c.
• Libtrace programs using DAG 2.5 and greater should now detach the DAG stream properly, provided they are exited cleanly.
• The snaplen can now be configured for DAG 2.5 and DAG 3.0 inputs

File:

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

lib/format_dag25.c

@@ -75 +75 @@
         int fd;
         unsigned int dagstream;
+        int stream_attached;
+        uint8_t *bottom;
+        uint8_t *top;
 };
 
@@ -105 +108 @@
         DUCK.last_pkt = 0;
         DUCK.dummy_duck = NULL;
-
+        FORMAT_DATA->stream_attached = 0;
+        
         return 0;
 }
@@ -111 +115 @@
 static int dag_config_input(libtrace_t *libtrace, trace_option_t option,
                                 void *data) {
-        switch(option) {
+        char conf_str[4096];
+        switch(option) {
                 case TRACE_OPTION_META_FREQ:
                         DUCK.duck_freq = *(int *)data;
                         return 0;
                 case TRACE_OPTION_SNAPLEN:
-                        /* Surely we can set this?? Fall through for now*/
-                        return -1;
+                        snprintf(conf_str, 4096, "varlen slen=%i", *(int *)data);
+                        if (dag_configure(FORMAT_DATA->fd, conf_str) != 0) {
+                                trace_set_err(libtrace, errno, "Failed to configure snaplen on DAG card: %s", libtrace->uridata);
+                                return -1;
+                        }
+                        return 0;
                 case TRACE_OPTION_PROMISC:
                         /* DAG already operates in a promisc fashion */
@@ -152 +161 @@
                 return -1;
         }
+        FORMAT_DATA->stream_attached = 1;
         /* We don't want the dag card to do any sleeping */
         dag_set_stream_poll(FORMAT_DATA->fd, 
@@ -158 +168 @@
         
         /* Should probably flush the memory hole now */
+        
         do {
                 top = dag_advance_stream(FORMAT_DATA->fd,
@@ -164 +175 @@
                 assert(top && bottom);
                 diff = top - bottom;
+                bottom -= diff;
         } while (diff != 0);
 
@@ -180 +192 @@
                 return -1;
         }
-
+        FORMAT_DATA->stream_attached = 0;
         return 0;
 }
 
 static int dag_fin_input(libtrace_t *libtrace) {
+        if (FORMAT_DATA->stream_attached)
+                dag_pause_input(libtrace);
+        dag_close(FORMAT_DATA->fd);
         if (DUCK.dummy_duck)
                 trace_destroy_dead(DUCK.dummy_duck);
@@ -193 +208 @@
 static int dag_get_duckinfo(libtrace_t *libtrace,
                                 libtrace_packet_t *packet) {
-        daginf_t lt_dag_inf;
-
         if (packet->buf_control == TRACE_CTRL_EXTERNAL ||
                         !packet->buffer) {
@@ -224 +237 @@
 }
 
-dag_record_t *dag_get_record(libtrace_t *libtrace) {
+static int dag_available(libtrace_t *libtrace) {
+        uint32_t diff = FORMAT_DATA->top - FORMAT_DATA->bottom;
+        if (diff >= dag_record_size)
+                return diff;
+        FORMAT_DATA->top = dag_advance_stream(FORMAT_DATA->fd, 
+                        FORMAT_DATA->dagstream, 
+                        &(FORMAT_DATA->bottom));
+        if (FORMAT_DATA->top == NULL) {
+                trace_set_err(libtrace, errno, "dag_advance_stream failed!");
+                return -1;
+        }
+        diff = FORMAT_DATA->top - FORMAT_DATA->bottom;
+        return diff;
+}
+
+static dag_record_t *dag_get_record(libtrace_t *libtrace) {
         dag_record_t *erfptr = NULL;
         uint16_t size;
-        erfptr = (dag_record_t *) dag_rx_stream_next_record(FORMAT_DATA->fd,
-                        FORMAT_DATA->dagstream);
+        erfptr = (dag_record_t *)FORMAT_DATA->bottom;
         if (!erfptr)
                 return NULL;
         size = ntohs(erfptr->rlen);
         assert( size >= dag_record_size );
+        /* Make certain we have the full packet available */
+        if (size > (FORMAT_DATA->top - FORMAT_DATA->bottom))
+                return NULL;
+        FORMAT_DATA->bottom += size;
         return erfptr;
 }
 
-void dag_form_packet(dag_record_t *erfptr, libtrace_packet_t *packet) {
+static void dag_form_packet(dag_record_t *erfptr, libtrace_packet_t *packet) {
         packet->buffer = erfptr;
         packet->header = erfptr;
@@ -257 +288 @@
         struct timeval tv;
         dag_record_t *erfptr = NULL;
-
+        int numbytes = 0;
+        
         if (DUCK.last_pkt - DUCK.last_duck > DUCK.duck_freq &&
                         DUCK.duck_freq != 0) {
@@ -276 +308 @@
 
         do {
+                numbytes = dag_available(libtrace);
+                if (numbytes < 0)
+                        return numbytes;
+                if (numbytes < dag_record_size)
+                        /* Block until we see a packet */
+                        continue;
                 erfptr = dag_get_record(libtrace);
         } while (erfptr == NULL);