Changeset 356


Ignore:
Timestamp:
08/26/05 11:22:23 (8 years ago)
Author:
spa1
Message:

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

Location:
trunk/lib
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/lib/Makefile.am

    r344 r356  
    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@ 

  • trunk/lib/dagformat.h

    r94 r356  
    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 

  • trunk/lib/fifo.c

    r250 r356  
    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 

  • trunk/lib/fifo.h

    r23 r356  
    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 

  • trunk/lib/format_erf.c

    r355 r356  
    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); 

  • trunk/lib/format_wag.c

    r355 r356  
    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; 

  • trunk/lib/libtrace_int.h

    r355 r356  
    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 

  • trunk/lib/trace.c

    r355 r356  
    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.