Changeset eb27e8e for lib/format_erf.c


Ignore:
Timestamp:
12/18/06 16:24:42 (15 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:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    r92a37b0 reb27e8e  
    108108        struct {
    109109                void *buf;
    110                 unsigned bottom;
    111                 unsigned top;
    112                 unsigned diff;
    113                 unsigned curr;
    114                 unsigned offset;
     110                uint32_t diff;
     111                uint32_t offset;
     112#ifdef DAG_VERSION_2_4
     113                uint32_t bottom;
     114                uint32_t top;
     115#else
     116                uint8_t *bottom;
     117                uint8_t *top;
    115118                unsigned int dagstream;
     119#endif
    116120        } dag;
    117121#endif
     
    164168                return -1;
    165169        }
    166 
     170#ifdef DAG_VERSION_2_4
     171        DAG.top = 0;
     172        DAG.bottom = 0;
     173#else
     174        DAG.top = NULL;
     175        DAG.bottom = NULL;
    167176        DAG.dagstream = 0;
    168        
     177#endif 
    169178        if (S_ISCHR(buf.st_mode)) {
    170179                /* DEVICE */
     
    519528#endif
    520529
    521 static int dag_read(libtrace_t *libtrace, int block_flag) {
     530static int dag_available(libtrace_t *libtrace) {
    522531
    523532        if (DAG.diff != 0)
     
    525534
    526535        DAG.bottom = DAG.top;
    527 
     536#ifdef DAG_VERSION_2_4
    528537        DAG.top = dag_offset(
    529538                        INPUT.fd,
    530539                        &(DAG.bottom),
    531                         block_flag);
    532 
     540                        DAGF_NONBLOCK);
     541
     542#else
     543        DAG.top = dag_advance_stream(INPUT.fd, DAG.dagstream, &(DAG.bottom));
     544#endif
    533545        DAG.diff = DAG.top - DAG.bottom;
    534546
     
    537549}
    538550
    539 /* FIXME: dag_read_packet shouldn't update the pointers, dag_fin_packet
    540  * should do that.
    541  */
    542 static int dag_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    543         int numbytes;
    544         int size;
    545         struct timeval tv;
     551dag_record_t *dag_get_record(libtrace_t *libtrace) {
    546552        dag_record_t *erfptr;
    547         char *next_record = NULL;       
    548 
    549         if (DUCK.last_pkt - DUCK.last_duck > DUCK.duck_freq &&
    550                         DUCK.duck_freq != 0) {
    551                 size = dag_get_duckinfo(libtrace, packet);
    552                 DUCK.last_duck = DUCK.last_pkt;
    553                 if (size != 0) {
    554                         return size;
    555                 }
    556                 /* No DUCK support, so don't waste our time anymore */
    557                 DUCK.duck_freq = 0;
    558         }
    559        
    560         if (packet->buf_control == TRACE_CTRL_PACKET) {
    561                 packet->buf_control = TRACE_CTRL_EXTERNAL;
    562                 free(packet->buffer);
    563                 packet->buffer = 0;
    564         }
    565        
    566         packet->type = TRACE_RT_DATA_ERF;
     553        uint16_t size;
    567554#ifdef DAG_VERSION_2_4
    568         if ((numbytes = dag_read(libtrace,0)) < 0)
    569                 return numbytes;
    570         assert(numbytes>0);
    571 
    572         /*DAG always gives us whole packets */
    573         erfptr = (dag_record_t *) ((char *)DAG.buf +
    574                         (DAG.bottom + DAG.offset));
     555        erfptr = (dag_record_t *) ((char *)DAG.buf + (DAG.bottom + DAG.offset));
    575556#else
    576         next_record = (char *)dag_rx_stream_next_record(INPUT.fd, 0);
    577         erfptr = (dag_record_t *)next_record;
     557        erfptr = (dag_record_t *) DAG.bottom;   
    578558#endif
    579559        size = ntohs(erfptr->rlen);
    580560        assert( size >= dag_record_size );
    581         assert( size < LIBTRACE_PACKET_BUFSIZE);
    582        
     561        DAG.offset += size;
     562        DAG.diff -= size;
     563        return erfptr;
     564}
     565
     566void dag_form_packet(dag_record_t *erfptr, libtrace_packet_t *packet) {
    583567        packet->buffer = erfptr;
    584568        packet->header = erfptr;
    585         if (((dag_record_t *)packet->buffer)->flags.rxerror == 1) {
     569        if (erfptr->flags.rxerror == 1) {
    586570                /* rxerror means the payload is corrupt - drop it
    587571                 * by tweaking rlen */
     
    593577        }
    594578
    595 #ifdef DAG_VERSION_2_4
    596         DAG.offset += size;
    597         DAG.diff -= size;
    598 #endif
     579}
     580
     581/* FIXME: dag_read_packet shouldn't update the pointers, dag_fin_packet
     582 * should do that.
     583 */
     584static int dag_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
     585        int numbytes;
     586        int size = 0;
     587        struct timeval tv;
     588        dag_record_t *erfptr;
     589
     590        if (DUCK.last_pkt - DUCK.last_duck > DUCK.duck_freq &&
     591                        DUCK.duck_freq != 0) {
     592                size = dag_get_duckinfo(libtrace, packet);
     593                DUCK.last_duck = DUCK.last_pkt;
     594                if (size != 0) {
     595                        return size;
     596                }
     597                /* No DUCK support, so don't waste our time anymore */
     598                DUCK.duck_freq = 0;
     599        }
     600       
     601        if (packet->buf_control == TRACE_CTRL_PACKET) {
     602                packet->buf_control = TRACE_CTRL_EXTERNAL;
     603                free(packet->buffer);
     604                packet->buffer = 0;
     605        }
     606       
     607        packet->type = TRACE_RT_DATA_ERF;
     608
     609        do {
     610                numbytes = dag_available(libtrace);
     611                if (numbytes < 0)
     612                        return numbytes;
     613        } while (numbytes == 0);
     614
     615        erfptr = dag_get_record(libtrace);
     616        dag_form_packet(erfptr, packet);
     617       
    599618        tv = trace_get_timeval(packet);
    600619        DUCK.last_pkt = tv.tv_sec;
    601        
    602         return packet->payload ? size : erf_get_framing_length(packet);
     620        return packet->payload ? ntohs(erfptr->rlen) : erf_get_framing_length(packet);
    603621}
    604622       
    605623static int dag_start_input(libtrace_t *libtrace) {
     624        struct timeval zero, nopoll;
     625        zero.tv_sec = 0;
     626        zero.tv_usec = 0;
     627        nopoll = zero;
     628
    606629#ifdef DAG_VERSION_2_4
    607630        if(dag_start(INPUT.fd) < 0) {
     
    619642                return -1;
    620643        }
     644        dag_set_stream_poll(INPUT.fd, DAG.dagstream, 0, &zero, &nopoll);
    621645#endif
    622646        /* dags appear to have a bug where if you call dag_start after
     
    624648         * happen.  flush the memory hole
    625649         */
    626         while(dag_read(libtrace,DAGF_NONBLOCK)!=0)
     650        while(dag_available(libtrace)!=0)
    627651                DAG.diff=0;
    628652        return 0;
     
    903927        }
    904928       
    905         data = dag_read(trace, DAGF_NONBLOCK);
     929        data = dag_available(trace);
    906930
    907931        if (data > 0) {
    908932                event.size = dag_read_packet(trace,packet);
    909                 DATA(trace)->dag.diff -= event.size;
     933                //DATA(trace)->dag.diff -= event.size;
    910934                if (trace->filter) {
    911935                        if (trace_apply_filter(trace->filter, packet)) {
Note: See TracChangeset for help on using the changeset viewer.