Changeset 4fd12ac for lib/trace.c

Timestamp:

10/25/04 20:42:36 (18 years ago)

Author:

Daniel Lawson <dlawson@…>

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:

24412fc

Parents:

dea6547

Message:

adding DAG support

File:

• lib/trace.c (modified) (20 diffs)

lib/trace.c

@@ -60 +60 @@
 #include <sys/socket.h>
 #include <sys/un.h>
+#include <sys/mman.h>
 #include <unistd.h>
 #include <net/ethernet.h>
@@ -72 +73 @@
 
 #ifdef HAVE_STDDEF_H
-#include <stddef.h>
+#  include <stddef.h>
 #else
 # error "Can't find stddef.h - do you define ptrdiff_t elsewhere?"
@@ -90 +91 @@
 #include <zlib.h>
 #include <pcap.h>
-
-#include "dagformat.h"
+#include <zlib.h>
+
 
 #include "wag.h"
 
+#ifdef HAVE_DAG_API
+#  include "dagnew.h"
+#  include "dagapi.h"
+#  define DAGDEVICE 1
+#else
+#  include "dagformat.h"
+#endif
 
 
@@ -123 +131 @@
         } input;
         struct fifo_t *fifo;   
+        void *buf; 
         struct {
                 void *buffer;
@@ -134 +143 @@
 static int init_trace(struct libtrace_t **libtrace, char *uri) {
         char *scan = calloc(sizeof(char),URI_PROTO_LINE);
-        char *uridata = 0;
+        char *uridata = 0;                  
+        struct stat buf;
         
         // parse the URI to determine what sort of event we are dealing with
@@ -190 +200 @@
                 case ERF:
                 case WAG:
-                case DAG:
                         /*
                          * Can have uridata of the following format
@@ -202 +211 @@
                                 (*libtrace)->sourcetype = STDIN;
                         } else {
-                                struct stat buf;
                                 if (stat(uridata,&buf) == -1) {
                                         perror("stat");
@@ -217 +225 @@
                         }
                         break;
+                case DAG:
+                        /* 
+                         * Can have uridata of the following format:
+                         * /dev/device
+                         */
+                        if (stat(uridata,&buf) == -1) {
+                                perror("stat");
+                                return 0;
+                        }
+                        if (S_ISCHR(buf.st_mode)) {
+                                (*libtrace)->sourcetype = DEVICE;
+                        } else {
+                                fprintf(stderr,"%s isn't a valid char device, exiting\n",uridata);
+                                exit(1);
+                        }
+                        (*libtrace)->conn_info.path = strdup(uridata);
+
+                        break;
 
                 case RTCLIENT:
@@ -249 +275 @@
 
         (*libtrace)->fifo = create_fifo(1048576);
-        (*libtrace)->packet.buffer = 0;
-        (*libtrace)->packet.size = 0;
+        //(*libtrace)->packet.buffer = 0;
+        //(*libtrace)->packet.size = 0;
 
         return 1;
@@ -370 +396 @@
                                                 O_RDONLY);
                                         break;
+#ifdef DAGDEVICE
+                                case DAG:
+                                        if((libtrace->input.fd = dag_open(libtrace->conn_info.path)) < 0) {
+                                                fprintf(stderr,"Cannot open DAG %s: %m", libtrace->conn_info.path,errno);
+                                                exit(0);
+                                        }
+                                        if((libtrace->buf = dag_mmap(libtrace->input.fd)) == MAP_FAILED) {
+                                                fprintf(stderr,"Cannot mmap DAG %s: %m", libtrace->conn_info.path,errno);
+                                                exit(0);
+                                        }
+                                        if(dag_start(libtrace->input.fd) < 0) {
+                                                fprintf(stderr,"Cannot start DAG %s: %m", libtrace->conn_info.path,errno);
+                                        }
+                                        break;
+#endif
+                                        
                         }
                         break;
@@ -399 +441 @@
 static int trace_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
         int numbytes;
-        assert(libtrace);
+        static unsigned bottom = 0, top, diff, curr, scan;
+        static short lctr = 0;
+        struct dag_record_t *recptr = 0;
+        int rlen;
+        assert(libtrace);
         assert(len >= 0);
 
@@ -424 +470 @@
                                 break;
                         case DEVICE:
-                                if ((numbytes=read(libtrace->input.fd, 
+                                switch(libtrace->format) {
+                                        case DAG:
+                                                top = dag_offset(libtrace->input.fd,
+                                                                &bottom,
+                                                                0);
+                                                diff = top - bottom;
+                                                errno = 0;
+                                                curr = 0;
+                                                
+                                                recptr = (dag_record_t *) (libtrace->buf + (bottom + curr));
+                                                
+                                                buffer=libtrace->buf + (bottom + curr);
+
+                                                numbytes=diff;
+                                                
+                                                
+                                                break;
+                                        default:
+                                                if ((numbytes=read(libtrace->input.fd, 
                                                                 buffer, 
                                                                 len)) == -1) {
-                                        perror("read");
-                                        return -1;
+                                                perror("read");
+                                                return -1;
+                                                }
                                 }
                                 break;
@@ -452 +517 @@
  *
  */
+#define RP_BUFSIZE 65536
 int trace_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
         int numbytes;
         int size;
-        char buf[4096];
+        char buf[RP_BUFSIZE];
         struct pcap_pkthdr pcaphdr;
         const u_char *pcappkt;
@@ -488 +554 @@
 
         /* If we're reading from an ERF input, it's an offline trace. We can make some assumptions */
-        
         if (libtrace->format == ERF) {
                 void *buffer2 = buffer;
@@ -518 +583 @@
         do {
                 if (fifo_out_available(libtrace->fifo) == 0 || read_required) {
-                        if ((numbytes = trace_read(libtrace,buf,4096))<=0){
+                        if ((numbytes = trace_read(libtrace,buf,RP_BUFSIZE))<=0){
                                 return numbytes; 
                         }
@@ -1046 +1111 @@
  * @author Perry Lorier
  */
-struct libtrace_eventobj_t libtrace_event(struct libtrace_t *trace, 
+struct libtrace_eventobj_t trace_event(struct libtrace_t *trace, 
                 struct libtrace_packet_t *packet) {
         struct libtrace_eventobj_t event;
+
+        if (!trace) {
+                fprintf(stderr,"You called trace_event() with a NULL trace object!\n");
+        }
+        assert(trace);
+        assert(packet);
+
+        /* Store the trace we are reading from into the packet opaque
+         * structure */
+        packet->trace = trace;
+
         /* Is there a packet ready? */
         switch (trace->sourcetype) {
@@ -1059 +1135 @@
                                 }
                                 if (data>0) {
+                                        trace_read_packet(trace,packet);
                                         event.type = TRACE_EVENT_PACKET;
+                                        return event;
                                 }
                                 event.type = TRACE_EVENT_IOWAIT;
+                                return event;
                         }
                 case SOCKET:
@@ -1068 +1147 @@
                         {
                                 int data;
-                                if(ioctl(trace->input.fd,FIONREAD,&data)==-1){
+                                event.fd = trace->input.fd;
+                                if(ioctl(event.fd,FIONREAD,&data)==-1){
                                         perror("ioctl(FIONREAD)");
                                 }
                                 if (data>0) {
+                                        trace_read_packet(trace,packet);
                                         event.type = TRACE_EVENT_PACKET;
-                                }
-                                event.fd = trace->input.fd;
+                                        return event;
+                                }
                                 event.type = TRACE_EVENT_IOWAIT;
+                                return event;
                         }
                 case STDIN:
@@ -1090 +1172 @@
                                 if (trace->last_ts!=0) {
                                         event.seconds = ts - trace->last_ts;
-                                        if (event.seconds>time(NULL)-trace->start_ts)
+                                        if (event.seconds>time(NULL)-trace->start_ts) {
                                                 event.type = TRACE_EVENT_SLEEP;
+                                                return event;
+                                        }
+                                        
                                 }
                                 else {
@@ -1104 +1189 @@
                                 trace->packet.buffer = 0;
                                 event.type = TRACE_EVENT_PACKET;
+                                return event;
                         }
                 default:
                         assert(0);
         }
-        return event;
+        assert(0);
 }