Changeset c5ac872

Timestamp:

02/05/15 14:07:27 (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:

1bad1e2

Parents:

3440627

Message:

Fixed compile error when using DAG 5.2 libraries

The name of the ioctl to fetch DUCK information had changed in DAG version 5
and the old one no longer worked.

Fixed bug where reading from a DAG card using trace_event would not
produce DUCK packets, even if the user requested them.

Added support for the new DUCK format present in DAG version 5.

Location:

lib

Files:

• format_dag25.c (modified) (7 diffs)
• format_duck.c (modified) (3 diffs)
• format_rt.c (modified) (1 diff)
• libtrace.h.in (modified) (1 diff)
• rt_protocol.h (modified) (1 diff)

lib/format_dag25.c

@@ -523 +523 @@
                         /* This option is used to specify the frequency of DUCK
                          * updates */
-                        DUCK.duck_freq = *(int *)data;
+                        DUCK.duck_freq = *(int *)data;
                         return 0;
                 case TRACE_OPTION_SNAPLEN:
@@ -584 +584 @@
         struct timeval zero, nopoll;
         uint8_t *top, *bottom, *starttop;
-        uint64_t diff = 0;
         top = bottom = NULL;
 
@@ -723 +722 @@
 }
 
+#ifdef DAGIOC_CARD_DUCK
+#define LIBTRACE_DUCK_IOCTL DAGIOC_CARD_DUCK
+#define LIBTRACE_DUCK_VERSION TRACE_RT_DUCK_5_0
+#else 
+#ifdef DAGIOCDUCK
+#define LIBTRACE_DUCK_IOCTL DAGIOCDUCK
+#define LIBTRACE_DUCK_VERSION TRACE_RT_DUCK_2_5
+#else
+#warning "DAG appears to be missing DUCK support"
+#endif
+#endif
+
 /* Extracts DUCK information from the DAG card and produces a DUCK packet */
 static int dag_get_duckinfo(libtrace_t *libtrace,
                                 libtrace_packet_t *packet) {
+
+        if (DUCK.duck_freq == 0)
+                return 0;
+
+#ifndef LIBTRACE_DUCK_IOCTL
+        trace_set_err(libtrace, errno, 
+                "Requested DUCK information but unable to determine the correct ioctl for DUCK");
+        DUCK.duck_freq = 0;
+        return -1;
+#endif
+
+        if (DUCK.last_pkt - DUCK.last_duck < DUCK.duck_freq)
+                return 0;
 
         /* Allocate memory for the DUCK data */
@@ -745 +769 @@
         /* No need to check if we can get DUCK or not - we're modern
          * enough so just grab the DUCK info */
-        if ((ioctl(FORMAT_DATA->device->fd, DAGIOCDUCK,
+        if ((ioctl(FORMAT_DATA->device->fd, LIBTRACE_DUCK_IOCTL,
                                         (duckinf_t *)packet->payload) < 0)) {
-                trace_set_err(libtrace, errno, "Error using DAGIOCDUCK");
+                trace_set_err(libtrace, errno, "Error using DUCK ioctl");
+                DUCK.duck_freq = 0;
                 return -1;
         }
 
-        packet->type = TRACE_RT_DUCK_2_5;
-
-        /* Set the packet's tracce to point at a DUCK trace, so that the
+        packet->type = LIBTRACE_DUCK_VERSION;
+
+        /* Set the packet's trace to point at a DUCK trace, so that the
          * DUCK format functions will be called on the packet rather than the
          * DAG ones */
         if (!DUCK.dummy_duck)
-                DUCK.dummy_duck = trace_create_dead("rt:localhost:3434");
+                DUCK.dummy_duck = trace_create_dead("duck:dummy");
         packet->trace = DUCK.dummy_duck;
+        DUCK.last_duck = DUCK.last_pkt;
         return sizeof(duckinf_t);
 }
@@ -1057 +1083 @@
 
         /* Check if we're due for a DUCK report */
-        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;
-        }
+        size = dag_get_duckinfo(libtrace, packet);
+
+        if (size != 0)
+                return size;
+
 
         /* Don't let anyone try to free our DAG memory hole! */
@@ -1124 +1145 @@
         int numbytes;
         uint32_t flags = 0;
-        struct timeval minwait;
+        struct timeval minwait, tv;
         
         minwait.tv_sec = 0;
         minwait.tv_usec = 10000;
+
+        /* Check if we're meant to provide a DUCK update */
+        numbytes = dag_get_duckinfo(libtrace, packet);
+        if (numbytes < 0) {
+                event.type = TRACE_EVENT_TERMINATE;
+                return event;
+        } else if (numbytes > 0) {
+                event.type = TRACE_EVENT_PACKET;
+                return event;
+        }
         
         if (dag_set_stream_poll(FORMAT_DATA->device->fd, 
@@ -1200 +1231 @@
                 }
 
+                /* Update the DUCK timer */
+                tv = trace_get_timeval(packet);
+                DUCK.last_pkt = tv.tv_sec;
+                
                 if (libtrace->snaplen > 0) {
                         trace_set_capture_length(packet, libtrace->snaplen);

lib/format_duck.c

@@ -216 +216 @@
                 duck_size = sizeof(duck2_5_t);
                 packet->type = TRACE_RT_DUCK_2_5;
+        } else if (DATA(libtrace)->dag_version == TRACE_RT_DUCK_5_0) {
+                duck_size = sizeof(duck5_0_t);
+                packet->type = TRACE_RT_DUCK_5_0;
         } else {
                 trace_set_err(libtrace, TRACE_ERR_BAD_PACKET,
@@ -252 +255 @@
 
         if (packet->type != TRACE_RT_DUCK_2_4 
-                        && packet->type != TRACE_RT_DUCK_2_5) {
+                        && packet->type != TRACE_RT_DUCK_2_5 &&
+                        packet->type != TRACE_RT_DUCK_5_0) {
                 trace_set_err_out(libtrace, TRACE_ERR_BAD_PACKET,
                                 "Only DUCK packets may be written to a DUCK file");
@@ -287 +291 @@
                 case TRACE_RT_DUCK_2_5:
                         return sizeof(duck2_5_t);
+                case TRACE_RT_DUCK_5_0:
+                        return sizeof(duck5_0_t);
                 default:
                         trace_set_err(packet->trace,TRACE_ERR_BAD_PACKET,

lib/format_rt.c

@@ -430 +430 @@
                 case TRACE_RT_DUCK_2_4:
                 case TRACE_RT_DUCK_2_5:
+                case TRACE_RT_DUCK_5_0:
                         if (!RT_INFO->dummy_duck) {
                                 RT_INFO->dummy_duck = trace_create_dead("duck:dummy");

lib/libtrace.h.in

@@ -383 +383 @@
         TRACE_RT_CLIENTDROP     =17,/**< Reliable client was lost */
         TRACE_RT_METADATA       =18,/**< Packet contains server meta-data */
+        TRACE_RT_DUCK_5_0       =19,/**< Dag 5.0 Duck */
 
         /** Not actually used - all DATA types begin from this value */

lib/rt_protocol.h

@@ -249 +249 @@
 } PACKED duck2_5_t;
 
+typedef struct duck5_0 {
+        int64_t         Phase_Correction;
+        uint64_t        Last_Ticks;
+        uint64_t        Last_TSC;
+        /* XXX Stat_Start and Stat_End are time_t in dagioctl.h, which means 
+         * they could in theory be 32 or 64 bit depending on the architecture 
+         * when capturing. I'm going to assume 5.0 era DAG captures are taking
+         * place on a 64 bit arch, rather than have to deal with the varying
+         * sizes (especially given nobody really uses DUCK these days).
+         */
+        uint64_t        Stat_Start, Stat_End;
+        uint32_t        Crystal_Freq;
+        uint32_t        Synth_Freq;
+        uint32_t        Resyncs;
+        uint32_t        Bad_Pulses;
+        uint32_t        Worst_Freq_Err, Worst_Phase_Err;
+        uint32_t        Health_Thresh;
+        uint32_t        Pulses, Single_Pulses_Missing, Longest_Pulse_Missing;
+        uint32_t        Health, Sickness;
+        int32_t         Freq_Err, Phase_Err;
+        uint32_t        Set_Duck_Field;
+} PACKED duck5_0_t;
+
 /*
 typedef struct rt_duck_2_4 {