Changeset b5cd711


Ignore:
Timestamp:
08/26/05 11:22:23 (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:
53f8305
Parents:
1974620
Message:

Changed all references to "fifo" to "tracefifo" with regards to function names and structures.
Fixes namespace conflicts with libfifo.

Location:
lib
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • lib/Makefile.am

    ra8ba977 rb5cd711  
    11lib_LTLIBRARIES = libtrace.la
    2 include_HEADERS = libtrace.h dagformat.h wag.h
     2include_HEADERS = libtrace.h dagformat.h wag.h 
    33libtrace_la_SOURCES = trace.c fifo.c fifo.h common.h format_template.c format_erf.c format_pcap.c format_wag.c format_helper.c format_helper.h rtserver.c rtserver.h parse_cmd.c parse_cmd.h libtrace_int.h
    44libtrace_la_CFLAGS = @ADD_INCLS@
  • lib/dagformat.h

    r299e9a0 rb5cd711  
    6262} __attribute__((packed)) dag_record_t;
    6363
     64
     65typedef struct duck_inf
     66{
     67        unsigned long   Command, Config, Clock_Inc, Clock_Wrap, DDS_Rate;
     68        unsigned long   Crystal_Freq;
     69        unsigned long   Synth_Freq, Sync_Rate;
     70        unsigned long   long Last_Ticks;
     71        unsigned long   Resyncs;
     72        unsigned long   Bad_Diffs, Bad_Offs, Bad_Pulses;
     73        unsigned long   Worst_Error, Worst_Off;
     74        unsigned long   Off_Limit, Off_Damp;
     75        unsigned long   Pulses, Single_Pulses_Missing, Longest_Pulse_Missing;
     76        unsigned long   Health, Sickness;
     77        long            Error, Offset;
     78        long            Stat_Start, Stat_End;   /* these are really time_t's */
     79        unsigned long   Set_Duck_Field;
     80} duck_inf;
     81
    6482#define dag_record_size         16
    6583
  • lib/fifo.c

    r23c13e8 rb5cd711  
    5757enum which_t { IN, OUT, ACK };
    5858
    59 struct fifo_t {
     59struct tracefifo_t {
    6060        size_t length;
    6161        size_t datamap[3];
     
    6666
    6767
    68 static char *fifo_stat_buffer = 0;
    69 
    70 static void increment_pointer(struct fifo_t *fifo, enum which_t which, int amount);
    71 static void set_pointer(struct fifo_t *fifo, enum which_t which, int location);
    72 static size_t fifo_compare(struct fifo_t *fifo, enum which_t first, enum which_t second);
    73 static int fifo_read_generic(struct fifo_t *fifo, void *buffer, size_t len, enum which_t which, char update);
    74 
    75 struct fifo_t *create_fifo(size_t size)
     68static char *tracefifo_stat_buffer = 0;
     69
     70static void increment_pointer(struct tracefifo_t *fifo, enum which_t which, int amount);
     71static void set_pointer(struct tracefifo_t *fifo, enum which_t which, int location);
     72static size_t tracefifo_compare(struct tracefifo_t *fifo, enum which_t first, enum which_t second);
     73static int tracefifo_read_generic(struct tracefifo_t *fifo, void *buffer, size_t len, enum which_t which, char update);
     74
     75struct tracefifo_t *create_tracefifo(size_t size)
    7676{
    7777        /* Set up our fifo
    7878        */
    79         struct fifo_t *fifo = malloc(sizeof(struct fifo_t));
     79        struct tracefifo_t *fifo = malloc(sizeof(struct tracefifo_t));
    8080        assert(size > 0);
    8181
    82         if (fifo_stat_buffer == 0)
    83                 fifo_stat_buffer = (char *)malloc(513);
     82        if (tracefifo_stat_buffer == 0)
     83                tracefifo_stat_buffer = (char *)malloc(513);
    8484        fifo->length = size;
    8585
     
    9595}
    9696
    97 void destroy_fifo(struct fifo_t *fifo)
    98 {
    99         assert(fifo);
    100         //free(fifo_stat_buffer);
     97void destroy_tracefifo(struct tracefifo_t *fifo)
     98{
     99        assert(fifo);
     100        //free(tracefifo_stat_buffer);
    101101        free(fifo->base);
    102102        free(fifo);
    103103}
    104104
    105 static void increment_pointer(struct fifo_t *fifo, enum which_t which, int amount) {
     105static void increment_pointer(struct tracefifo_t *fifo, enum which_t which, int amount) {
    106106        assert(fifo);
    107107        assert(which == IN || which == OUT || which == ACK);
     
    115115}
    116116
    117 void fifo_flush(struct fifo_t *fifo) {
     117void tracefifo_flush(struct tracefifo_t *fifo) {
    118118        // do nothing
    119119        return;
    120120}
    121121
    122 static void set_pointer(struct fifo_t *fifo, enum which_t which, int location) {
     122static void set_pointer(struct tracefifo_t *fifo, enum which_t which, int location) {
    123123        assert(fifo);
    124124        assert(which == IN || which == OUT || which == ACK);
     
    130130}
    131131
    132 static size_t fifo_compare(struct fifo_t *fifo, enum which_t first, enum which_t second) {
     132static size_t tracefifo_compare(struct tracefifo_t *fifo, enum which_t first, enum which_t second) {
    133133        assert(fifo);
    134134        assert(first == IN || first == OUT || first == ACK);
     
    145145}
    146146
    147 size_t fifo_free(struct fifo_t *fifo) {
    148         assert(fifo);
    149         return (fifo->length - fifo_compare(fifo,IN,ACK));
     147size_t tracefifo_free(struct tracefifo_t *fifo) {
     148        assert(fifo);
     149        return (fifo->length - tracefifo_compare(fifo,IN,ACK));
    150150}
    151151
    152 size_t fifo_length(struct fifo_t *fifo) {
     152size_t tracefifo_length(struct tracefifo_t *fifo) {
    153153        assert(fifo);
    154154        return fifo->length;
    155155}
    156156
    157 size_t fifo_out_available(struct fifo_t *fifo) {
    158         assert(fifo);
    159         return fifo_compare(fifo,IN,OUT);
    160 }
    161 
    162 size_t fifo_ack_available(struct fifo_t *fifo) {
    163         assert(fifo);
    164         return fifo_compare(fifo,OUT,ACK);
    165 }
    166 
    167 void fifo_stat_int(struct fifo_t *fifo, fifo_state_t *state)
     157size_t tracefifo_out_available(struct tracefifo_t *fifo) {
     158        assert(fifo);
     159        return tracefifo_compare(fifo,IN,OUT);
     160}
     161
     162size_t tracefifo_ack_available(struct tracefifo_t *fifo) {
     163        assert(fifo);
     164        return tracefifo_compare(fifo,OUT,ACK);
     165}
     166
     167void tracefifo_stat_int(struct tracefifo_t *fifo, tracefifo_state_t *state)
    168168{
    169169        assert(fifo);
     
    174174        state->ack = fifo->datamap[ACK];
    175175        state->length = fifo->length;
    176         state->used = fifo_compare(fifo,IN,ACK);
    177 
    178 }
    179 char *fifo_stat_str(struct fifo_t *fifo, char *desc, int delta)
     176        state->used = tracefifo_compare(fifo,IN,ACK);
     177
     178}
     179char *tracefifo_stat_str(struct tracefifo_t *fifo, char *desc, int delta)
    180180{
    181181        char *scan = 0;
    182182        assert(fifo);
    183183
    184         bzero(fifo_stat_buffer,513);
    185         scan = fifo_stat_buffer;
     184        bzero(tracefifo_stat_buffer,513);
     185        scan = tracefifo_stat_buffer;
    186186        if (desc)
    187187                scan += sprintf(scan,"%s\t",desc);
     
    191191        if (delta > 0)
    192192                scan += sprintf(scan,"delta: %d\t", delta);
    193         scan += sprintf(scan,"Size: %d", fifo_compare(fifo,IN,ACK));
     193        scan += sprintf(scan,"Size: %d", tracefifo_compare(fifo,IN,ACK));
    194194        scan += sprintf(scan,"\n");
    195         return fifo_stat_buffer;
    196 }
    197 void fifo_stat(struct fifo_t *fifo, char *desc, int delta)
    198 {
    199         assert(fifo);
    200 
    201         printf("%s",fifo_stat_str(fifo,desc,delta));
     195        return tracefifo_stat_buffer;
     196}
     197void tracefifo_stat(struct tracefifo_t *fifo, char *desc, int delta)
     198{
     199        assert(fifo);
     200
     201        printf("%s",tracefifo_stat_str(fifo,desc,delta));
    202202}
    203203
     
    206206 * starting at the pointer corresponding to which - if thats bogus data then its not
    207207 * the fault of this function */
    208 static int fifo_read_generic(struct fifo_t *fifo, void *buffer, size_t len, enum which_t which, char update) {
     208static int tracefifo_read_generic(struct tracefifo_t *fifo, void *buffer, size_t len, enum which_t which, char update) {
    209209        size_t oldptr;
    210210        int lenleft;
     
    232232}
    233233
    234 int fifo_write(struct fifo_t *fifo, void *buffer, size_t len) {
     234int tracefifo_write(struct tracefifo_t *fifo, void *buffer, size_t len) {
    235235        int lenleft;
    236236        int size;
     
    239239        assert(len >= 0);
    240240
    241         if (fifo_free(fifo) < len) {
     241        if (tracefifo_free(fifo) < len) {
    242242                return 0;
    243243        }
     
    257257
    258258
    259 int fifo_out_read(struct fifo_t *fifo, void *buffer, size_t len) {
     259int tracefifo_out_read(struct tracefifo_t *fifo, void *buffer, size_t len) {
    260260        assert(fifo);
    261261        assert(buffer);
    262262        assert(len >= 0);
    263         if (fifo_compare(fifo,IN,OUT) < len) {
    264                 return 0;
    265         }
    266         return fifo_read_generic(fifo,buffer,len,OUT,0);
    267 }
    268 
    269 int fifo_ack_read(struct fifo_t *fifo, void *buffer, size_t len) {
     263        if (tracefifo_compare(fifo,IN,OUT) < len) {
     264                return 0;
     265        }
     266        return tracefifo_read_generic(fifo,buffer,len,OUT,0);
     267}
     268
     269int tracefifo_ack_read(struct tracefifo_t *fifo, void *buffer, size_t len) {
    270270        assert(fifo);
    271271        assert(buffer);
    272272        assert(len >= 0);
    273         if (fifo_compare(fifo,OUT,ACK) < len) {
    274                 return 0;
    275         }
    276         return fifo_read_generic(fifo,buffer,len,ACK,0);
    277 }
    278 
    279 int fifo_out_update(struct fifo_t *fifo, size_t len){
    280         assert(fifo);
    281         assert(len >= 0);
    282         if (fifo_compare(fifo,IN,OUT) < len) {
     273        if (tracefifo_compare(fifo,OUT,ACK) < len) {
     274                return 0;
     275        }
     276        return tracefifo_read_generic(fifo,buffer,len,ACK,0);
     277}
     278
     279int tracefifo_out_update(struct tracefifo_t *fifo, size_t len){
     280        assert(fifo);
     281        assert(len >= 0);
     282        if (tracefifo_compare(fifo,IN,OUT) < len) {
    283283                return 0;
    284284        }
     
    287287}
    288288
    289 int fifo_ack_update(struct fifo_t *fifo, size_t len){
    290         assert(fifo);
    291         assert(len >= 0);
    292         if (fifo_compare(fifo,OUT,ACK) < len) {
     289int tracefifo_ack_update(struct tracefifo_t *fifo, size_t len){
     290        assert(fifo);
     291        assert(len >= 0);
     292        if (tracefifo_compare(fifo,OUT,ACK) < len) {
    293293                return 0;
    294294        }
     
    297297}
    298298
    299 void fifo_out_reset(struct fifo_t *fifo) {
     299void tracefifo_out_reset(struct tracefifo_t *fifo) {
    300300        /*
    301301         * This will reset the sent pointer back to the ack pointer. This
  • lib/fifo.h

    ra79ddbe rb5cd711  
    3333#define _FIFO_H_
    3434
    35 struct fifo_t;
     35struct tracefifo_t;
    3636
    37 typedef struct fifo_state {
     37typedef struct tracefifo_state {
    3838        long long int in;
    3939        long long int out;
     
    4141        long long int length;
    4242        long long int used;
    43 } fifo_state_t;
     43} tracefifo_state_t;
    4444
    4545
    46 struct fifo_t *create_fifo(size_t size);
    47 void destroy_fifo(struct fifo_t *fifo);
     46struct tracefifo_t *create_tracefifo(size_t size);
     47void destroy_tracefifo(struct tracefifo_t *fifo);
    4848
    4949
    50 void fifo_stat(struct fifo_t *fifo, char *desc, int delta);
    51 char *fifo_stat_str(struct fifo_t *fifo, char *desc, int delta);
    52 void fifo_stat_int(struct fifo_t *fifo, fifo_state_t *state);
     50void tracefifo_stat(struct tracefifo_t *fifo, char *desc, int delta);
     51char *tracefifo_stat_str(struct tracefifo_t *fifo, char *desc, int delta);
     52void tracefifo_stat_int(struct tracefifo_t *fifo, tracefifo_state_t *state);
    5353
    54 size_t fifo_out_available(struct fifo_t *fifo);
    55 size_t fifo_ack_available(struct fifo_t *fifo);
    56 size_t fifo_free(struct fifo_t *fifo);
    57 size_t fifo_length(struct fifo_t *fifo);
     54size_t tracefifo_out_available(struct tracefifo_t *fifo);
     55size_t tracefifo_ack_available(struct tracefifo_t *fifo);
     56size_t tracefifo_free(struct tracefifo_t *fifo);
     57size_t tracefifo_length(struct tracefifo_t *fifo);
    5858
    59 int fifo_write(struct fifo_t *fifo, void *buffer, size_t len);
     59int tracefifo_write(struct tracefifo_t *fifo, void *buffer, size_t len);
    6060
    61 int fifo_out_read(struct fifo_t *fifo, void *buffer, size_t len);
    62 int fifo_ack_read(struct fifo_t *fifo, void *buffer, size_t len);
    63 int fifo_out_update(struct fifo_t *fifo, size_t len);
    64 int fifo_ack_update(struct fifo_t *fifo, size_t len);
     61int tracefifo_out_read(struct tracefifo_t *fifo, void *buffer, size_t len);
     62int tracefifo_ack_read(struct tracefifo_t *fifo, void *buffer, size_t len);
     63int tracefifo_out_update(struct tracefifo_t *fifo, size_t len);
     64int tracefifo_ack_update(struct tracefifo_t *fifo, size_t len);
    6565
    66 void fifo_out_reset(struct fifo_t *fifo);
     66void tracefifo_out_reset(struct tracefifo_t *fifo);
    6767
    68 void fifo_flush(struct fifo_t *fifo);
     68void tracefifo_flush(struct tracefifo_t *fifo);
    6969
    7070
  • lib/format_erf.c

    r1974620 rb5cd711  
    572572
    573573        do {
    574                 if (fifo_out_available(libtrace->fifo) == 0 || read_required) {
     574                if (tracefifo_out_available(libtrace->fifo) == 0 || read_required) {
    575575                        if ((numbytes = rtclient_read(
    576576                                        libtrace,buf,RP_BUFSIZE))<=0) {
    577577                                return numbytes;
    578578                        }
    579                         fifo_write(libtrace->fifo,buf,numbytes);
     579                        tracefifo_write(libtrace->fifo,buf,numbytes);
    580580                        read_required = 0;
    581581                }
    582582                // Read status byte
    583                 if (fifo_out_read(libtrace->fifo,
     583                if (tracefifo_out_read(libtrace->fifo,
    584584                                &packet->status, sizeof(int)) == 0) {
    585585                        read_required = 1;
    586586                        continue;
    587587                }
    588                 fifo_out_update(libtrace->fifo,sizeof(int));
     588                tracefifo_out_update(libtrace->fifo,sizeof(int));
    589589
    590590                // read in the ERF header
    591                 if ((numbytes = fifo_out_read(libtrace->fifo, buffer,
     591                if ((numbytes = tracefifo_out_read(libtrace->fifo, buffer,
    592592                                                sizeof(dag_record_t))) == 0) {
    593                         fifo_out_reset(libtrace->fifo);
     593                        tracefifo_out_reset(libtrace->fifo);
    594594                        read_required = 1;
    595595                        continue;
     
    598598               
    599599                // read in the full packet
    600                 if ((numbytes = fifo_out_read(libtrace->fifo,
     600                if ((numbytes = tracefifo_out_read(libtrace->fifo,
    601601                                                buffer, size)) == 0) {
    602                         fifo_out_reset(libtrace->fifo);
     602                        tracefifo_out_reset(libtrace->fifo);
    603603                        read_required = 1;
    604604                        continue;
     
    606606
    607607                // got in our whole packet, so...
    608                 fifo_out_update(libtrace->fifo,size);
    609 
    610                 fifo_ack_update(libtrace->fifo,size + sizeof(int));
     608                tracefifo_out_update(libtrace->fifo,size);
     609
     610                tracefifo_ack_update(libtrace->fifo,size + sizeof(int));
    611611
    612612                packet->size = numbytes;
     
    699699
    700700                assert(libtrace->fifo);
    701                 if (fifo_out_available(libtrace->fifo) == 0 || write_required) {
     701                if (tracefifo_out_available(libtrace->fifo) == 0 || write_required) {
    702702                        // Packet added to fifo
    703                         if ((numbytes = fifo_write(libtrace->fifo, packet->buffer, packet->size)) == 0) {
     703                        if ((numbytes = tracefifo_write(libtrace->fifo, packet->buffer, packet->size)) == 0) {
    704704                                // some error with the fifo
    705                                 perror("fifo_write");
     705                                perror("tracefifo_write");
    706706                                return -1;
    707707                        }
     
    710710
    711711                // Read from fifo and add protocol header
    712                 if ((numbytes = fifo_out_read(libtrace->fifo, buffer, sizeof(dag_record_t))) == 0) {
     712                if ((numbytes = tracefifo_out_read(libtrace->fifo, buffer, sizeof(dag_record_t))) == 0) {
    713713                        // failure reading in from fifo
    714                         fifo_out_reset(libtrace->fifo);
     714                        tracefifo_out_reset(libtrace->fifo);
    715715                        write_required = 1;
    716716                        continue;
     
    718718                size = ntohs(((dag_record_t *)buffer)->rlen);
    719719                assert(size < LIBTRACE_PACKET_BUFSIZE);
    720                 if ((numbytes = fifo_out_read(libtrace->fifo, buffer, size)) == 0) {
     720                if ((numbytes = tracefifo_out_read(libtrace->fifo, buffer, size)) == 0) {
    721721                       // failure reading in from fifo
    722                        fifo_out_reset(libtrace->fifo);
     722                       tracefifo_out_reset(libtrace->fifo);
    723723                       write_required = 1;
    724724                       continue;
     
    733733
    734734
    735                 fifo_out_update(libtrace->fifo, size);
    736                 fifo_ack_update(libtrace->fifo, size);
     735                tracefifo_out_update(libtrace->fifo, size);
     736                tracefifo_ack_update(libtrace->fifo, size);
    737737                return numbytes;
    738738        } while(1);
  • lib/format_wag.c

    r1974620 rb5cd711  
    312312
    313313        do {
    314                 if (fifo_out_available(libtrace->fifo) == 0 || read_required) {
     314                if (tracefifo_out_available(libtrace->fifo) == 0 || read_required) {
    315315                        if ((numbytes = wag_read(libtrace,buf,RP_BUFSIZE)) <= 0) {
    316316                                return numbytes;
    317317                        }
    318318                        assert(libtrace->fifo);
    319                         fifo_write(libtrace->fifo,buf,numbytes);
     319                        tracefifo_write(libtrace->fifo,buf,numbytes);
    320320                        read_required = 0;
    321321                }
    322322                // read in wag_frame_hdr
    323                 if ((numbytes = fifo_out_read(libtrace->fifo,
     323                if ((numbytes = tracefifo_out_read(libtrace->fifo,
    324324                                                buffer,
    325325                                                sizeof(struct wag_frame_hdr)))
    326326                                == 0 ) {
    327                         fifo_out_reset(libtrace->fifo);
     327                        tracefifo_out_reset(libtrace->fifo);
    328328                        read_required = 1;
    329329                        continue;
     
    337337
    338338                // read in full packet
    339                 if((numbytes = fifo_out_read(libtrace->fifo,buffer,size)) == 0) {
    340                         fifo_out_reset(libtrace->fifo);
     339                if((numbytes = tracefifo_out_read(libtrace->fifo,buffer,size)) == 0) {
     340                        tracefifo_out_reset(libtrace->fifo);
    341341                        read_required = 1;
    342342                        continue;
     
    344344
    345345                // have the whole packet
    346                 fifo_out_update(libtrace->fifo,size);
    347                 fifo_ack_update(libtrace->fifo,size);
     346                tracefifo_out_update(libtrace->fifo,size);
     347                tracefifo_ack_update(libtrace->fifo,size);
    348348
    349349                packet->size = numbytes;
  • lib/libtrace_int.h

    r1974620 rb5cd711  
    108108        struct libtrace_event_t event;
    109109        char *uridata;
    110         struct fifo_t *fifo;   
     110        struct tracefifo_t *fifo;   
    111111
    112112};
     
    117117
    118118        char *uridata;
    119         struct fifo_t *fifo;
     119        struct tracefifo_t *fifo;
    120120};
    121121
  • lib/trace.c

    r1974620 rb5cd711  
    302302       
    303303
    304         libtrace->fifo = create_fifo(1048576);
     304        libtrace->fifo = create_tracefifo(1048576);
    305305        assert( libtrace->fifo);
    306306
     
    376376
    377377
    378         libtrace->fifo = create_fifo(1048576);
     378        libtrace->fifo = create_tracefifo(1048576);
    379379        assert( libtrace->fifo);
    380380
     
    417417        // need to free things!
    418418        free(libtrace->uridata);
    419         destroy_fifo(libtrace->fifo);
     419        destroy_tracefifo(libtrace->fifo);
    420420        free(libtrace);
    421421}
     
    431431        libtrace->format->fin_output(libtrace);
    432432        free(libtrace->uridata);
    433         destroy_fifo(libtrace->fifo);
     433        destroy_tracefifo(libtrace->fifo);
    434434        free(libtrace);
    435435}
Note: See TracChangeset for help on using the changeset viewer.