Changeset 4fd12ac for lib/trace.c


Ignore:
Timestamp:
10/25/04 20:42:36 (17 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:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/trace.c

    rdea6547 r4fd12ac  
    6060#include <sys/socket.h>
    6161#include <sys/un.h>
     62#include <sys/mman.h>
    6263#include <unistd.h>
    6364#include <net/ethernet.h>
     
    7273
    7374#ifdef HAVE_STDDEF_H
    74 #include <stddef.h>
     75#  include <stddef.h>
    7576#else
    7677# error "Can't find stddef.h - do you define ptrdiff_t elsewhere?"
     
    9091#include <zlib.h>
    9192#include <pcap.h>
    92 
    93 #include "dagformat.h"
     93#include <zlib.h>
     94
    9495
    9596#include "wag.h"
    9697
     98#ifdef HAVE_DAG_API
     99#  include "dagnew.h"
     100#  include "dagapi.h"
     101#  define DAGDEVICE 1
     102#else
     103#  include "dagformat.h"
     104#endif
    97105
    98106
     
    123131        } input;
    124132        struct fifo_t *fifo;   
     133        void *buf;
    125134        struct {
    126135                void *buffer;
     
    134143static int init_trace(struct libtrace_t **libtrace, char *uri) {
    135144        char *scan = calloc(sizeof(char),URI_PROTO_LINE);
    136         char *uridata = 0;
     145        char *uridata = 0;                 
     146        struct stat buf;
    137147       
    138148        // parse the URI to determine what sort of event we are dealing with
     
    190200                case ERF:
    191201                case WAG:
    192                 case DAG:
    193202                        /*
    194203                         * Can have uridata of the following format
     
    202211                                (*libtrace)->sourcetype = STDIN;
    203212                        } else {
    204                                 struct stat buf;
    205213                                if (stat(uridata,&buf) == -1) {
    206214                                        perror("stat");
     
    217225                        }
    218226                        break;
     227                case DAG:
     228                        /*
     229                         * Can have uridata of the following format:
     230                         * /dev/device
     231                         */
     232                        if (stat(uridata,&buf) == -1) {
     233                                perror("stat");
     234                                return 0;
     235                        }
     236                        if (S_ISCHR(buf.st_mode)) {
     237                                (*libtrace)->sourcetype = DEVICE;
     238                        } else {
     239                                fprintf(stderr,"%s isn't a valid char device, exiting\n",uridata);
     240                                exit(1);
     241                        }
     242                        (*libtrace)->conn_info.path = strdup(uridata);
     243
     244                        break;
    219245
    220246                case RTCLIENT:
     
    249275
    250276        (*libtrace)->fifo = create_fifo(1048576);
    251         (*libtrace)->packet.buffer = 0;
    252         (*libtrace)->packet.size = 0;
     277        //(*libtrace)->packet.buffer = 0;
     278        //(*libtrace)->packet.size = 0;
    253279
    254280        return 1;
     
    370396                                                O_RDONLY);
    371397                                        break;
     398#ifdef DAGDEVICE
     399                                case DAG:
     400                                        if((libtrace->input.fd = dag_open(libtrace->conn_info.path)) < 0) {
     401                                                fprintf(stderr,"Cannot open DAG %s: %m", libtrace->conn_info.path,errno);
     402                                                exit(0);
     403                                        }
     404                                        if((libtrace->buf = dag_mmap(libtrace->input.fd)) == MAP_FAILED) {
     405                                                fprintf(stderr,"Cannot mmap DAG %s: %m", libtrace->conn_info.path,errno);
     406                                                exit(0);
     407                                        }
     408                                        if(dag_start(libtrace->input.fd) < 0) {
     409                                                fprintf(stderr,"Cannot start DAG %s: %m", libtrace->conn_info.path,errno);
     410                                        }
     411                                        break;
     412#endif
     413                                       
    372414                        }
    373415                        break;
     
    399441static int trace_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
    400442        int numbytes;
    401         assert(libtrace);
     443        static unsigned bottom = 0, top, diff, curr, scan;
     444        static short lctr = 0;
     445        struct dag_record_t *recptr = 0;
     446        int rlen;
     447        assert(libtrace);
    402448        assert(len >= 0);
    403449
     
    424470                                break;
    425471                        case DEVICE:
    426                                 if ((numbytes=read(libtrace->input.fd,
     472                                switch(libtrace->format) {
     473                                        case DAG:
     474                                                top = dag_offset(libtrace->input.fd,
     475                                                                &bottom,
     476                                                                0);
     477                                                diff = top - bottom;
     478                                                errno = 0;
     479                                                curr = 0;
     480                                               
     481                                                recptr = (dag_record_t *) (libtrace->buf + (bottom + curr));
     482                                               
     483                                                buffer=libtrace->buf + (bottom + curr);
     484
     485                                                numbytes=diff;
     486                                               
     487                                               
     488                                                break;
     489                                        default:
     490                                                if ((numbytes=read(libtrace->input.fd,
    427491                                                                buffer,
    428492                                                                len)) == -1) {
    429                                         perror("read");
    430                                         return -1;
     493                                                perror("read");
     494                                                return -1;
     495                                                }
    431496                                }
    432497                                break;
     
    452517 *
    453518 */
     519#define RP_BUFSIZE 65536
    454520int trace_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
    455521        int numbytes;
    456522        int size;
    457         char buf[4096];
     523        char buf[RP_BUFSIZE];
    458524        struct pcap_pkthdr pcaphdr;
    459525        const u_char *pcappkt;
     
    488554
    489555        /* If we're reading from an ERF input, it's an offline trace. We can make some assumptions */
    490        
    491556        if (libtrace->format == ERF) {
    492557                void *buffer2 = buffer;
     
    518583        do {
    519584                if (fifo_out_available(libtrace->fifo) == 0 || read_required) {
    520                         if ((numbytes = trace_read(libtrace,buf,4096))<=0){
     585                        if ((numbytes = trace_read(libtrace,buf,RP_BUFSIZE))<=0){
    521586                                return numbytes;
    522587                        }
     
    10461111 * @author Perry Lorier
    10471112 */
    1048 struct libtrace_eventobj_t libtrace_event(struct libtrace_t *trace,
     1113struct libtrace_eventobj_t trace_event(struct libtrace_t *trace,
    10491114                struct libtrace_packet_t *packet) {
    10501115        struct libtrace_eventobj_t event;
     1116
     1117        if (!trace) {
     1118                fprintf(stderr,"You called trace_event() with a NULL trace object!\n");
     1119        }
     1120        assert(trace);
     1121        assert(packet);
     1122
     1123        /* Store the trace we are reading from into the packet opaque
     1124         * structure */
     1125        packet->trace = trace;
     1126
    10511127        /* Is there a packet ready? */
    10521128        switch (trace->sourcetype) {
     
    10591135                                }
    10601136                                if (data>0) {
     1137                                        trace_read_packet(trace,packet);
    10611138                                        event.type = TRACE_EVENT_PACKET;
     1139                                        return event;
    10621140                                }
    10631141                                event.type = TRACE_EVENT_IOWAIT;
     1142                                return event;
    10641143                        }
    10651144                case SOCKET:
     
    10681147                        {
    10691148                                int data;
    1070                                 if(ioctl(trace->input.fd,FIONREAD,&data)==-1){
     1149                                event.fd = trace->input.fd;
     1150                                if(ioctl(event.fd,FIONREAD,&data)==-1){
    10711151                                        perror("ioctl(FIONREAD)");
    10721152                                }
    10731153                                if (data>0) {
     1154                                        trace_read_packet(trace,packet);
    10741155                                        event.type = TRACE_EVENT_PACKET;
    1075                                 }
    1076                                 event.fd = trace->input.fd;
     1156                                        return event;
     1157                                }
    10771158                                event.type = TRACE_EVENT_IOWAIT;
     1159                                return event;
    10781160                        }
    10791161                case STDIN:
     
    10901172                                if (trace->last_ts!=0) {
    10911173                                        event.seconds = ts - trace->last_ts;
    1092                                         if (event.seconds>time(NULL)-trace->start_ts)
     1174                                        if (event.seconds>time(NULL)-trace->start_ts) {
    10931175                                                event.type = TRACE_EVENT_SLEEP;
     1176                                                return event;
     1177                                        }
     1178                                       
    10941179                                }
    10951180                                else {
     
    11041189                                trace->packet.buffer = 0;
    11051190                                event.type = TRACE_EVENT_PACKET;
     1191                                return event;
    11061192                        }
    11071193                default:
    11081194                        assert(0);
    11091195        }
    1110         return event;
     1196        assert(0);
    11111197}
    11121198
Note: See TracChangeset for help on using the changeset viewer.