Changeset f0fb38f for lib/format_rt.c


Ignore:
Timestamp:
03/26/08 10:45:36 (14 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:
f52bcdd
Parents:
e632f2f
Message:
  • Added prepare_packet functions to all formats, primarily to support translating RT packets into the appropriate format. These functions are all used internally as well, as most formats still need to "prepare" packets that have been read by setting pointers, updating loss counters etc.
  • Also added a trace_prepare_packet function, but this is not made available externally at this stage
  • Added init_format_data functions to some formats to initialise format data structures in cases where the init_trace function does more than just that
  • Refactored rt packet reading code to use the new trace_prepare_packet functionality - also did a lot of tidying of the code
  • Added missing RT type for BPF format
File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_rt.c

    rf3f3558 rf0fb38f  
    188188}
    189189
    190 
    191 static int rt_init_input(libtrace_t *libtrace) {
    192         char *scan;
    193         char *uridata = libtrace->uridata;
     190static void rt_init_format_data(libtrace_t *libtrace) {
    194191        libtrace->format_data = malloc(sizeof(struct rt_format_data_t));
    195192
     
    201198        RT_INFO->buf_current = NULL;
    202199        RT_INFO->buf_filled = 0;
     200        RT_INFO->hostname = NULL;
     201        RT_INFO->port = 0;
     202}
     203
     204static int rt_init_input(libtrace_t *libtrace) {
     205        char *scan;
     206        char *uridata = libtrace->uridata;
     207
     208        rt_init_format_data(libtrace);
    203209       
    204210        if (strlen(uridata) == 0) {
     
    394400                        packet->trace = RT_INFO->dummy_linux;
    395401                        break;
     402                case TRACE_RT_STATUS:
     403                case TRACE_RT_METADATA:
     404                        /* Just use the RT trace! */
     405                        packet->trace = libtrace;
     406                        break;
    396407                case TRACE_RT_DATA_LEGACY_ETH:
    397408                case TRACE_RT_DATA_LEGACY_ATM:
     
    407418        return 0; /* success */
    408419}               
    409 
    410 static void rt_set_payload(libtrace_packet_t *packet) {
    411         dag_record_t *erfptr;
    412        
    413         switch (packet->type) {
    414                 case TRACE_RT_DATA_ERF:
    415                         erfptr = (dag_record_t *)packet->header;
    416                        
    417                         if (erfptr->flags.rxerror == 1) {
    418                                 packet->payload = NULL;
    419                                 break;
    420                         }
    421                         /* else drop into the default case */
    422                 default:
    423                         packet->payload = (char *)packet->buffer +
    424                                 trace_get_framing_length(packet);
    425                         break;
    426         }
    427 }
    428420
    429421static int rt_send_ack(libtrace_t *libtrace,
     
    475467}
    476468
    477        
     469static int rt_prepare_packet(libtrace_t *libtrace, libtrace_packet_t *packet,
     470                void *buffer, libtrace_rt_types_t rt_type, uint32_t flags) {
     471
     472        if (packet->buffer != buffer &&
     473                        packet->buf_control == TRACE_CTRL_PACKET) {
     474                free(packet->buffer);
     475        }
     476
     477        if ((flags & TRACE_PREP_OWN_BUFFER) == TRACE_PREP_OWN_BUFFER) {
     478                packet->buf_control = TRACE_CTRL_PACKET;
     479        } else
     480                packet->buf_control = TRACE_CTRL_EXTERNAL;
     481
     482
     483        packet->buffer = buffer;
     484        packet->header = NULL;
     485        packet->type = rt_type;
     486        packet->payload = buffer;
     487
     488        if (libtrace->format_data == NULL) {
     489                rt_init_format_data(libtrace);
     490        }
     491
     492        return 0;
     493}       
     494
     495static int rt_read_data_packet(libtrace_t *libtrace,
     496                libtrace_packet_t *packet, int blocking) {
     497        uint32_t prep_flags = 0;
     498       
     499        if (rt_read(libtrace, &packet->buffer, (size_t)RT_INFO->rt_hdr.length,
     500                                blocking) != RT_INFO->rt_hdr.length) {
     501                return -1;
     502        }
     503
     504        if (RT_INFO->reliable > 0 && packet->type >= TRACE_RT_DATA_SIMPLE) {
     505                if (rt_send_ack(libtrace, RT_INFO->rt_hdr.sequence) == -1)
     506                                return -1;
     507        }
     508       
     509        if (rt_set_format(libtrace, packet) < 0) {
     510                return -1;
     511        }
     512               
     513        /* Update payload pointers and loss counters correctly */
     514        if (trace_prepare_packet(packet->trace, packet, packet->buffer,
     515                                packet->type, prep_flags)) {
     516                return -1;
     517        }
     518
     519        return 0;
     520}
     521
    478522static int rt_read_packet_versatile(libtrace_t *libtrace,
    479523                libtrace_packet_t *packet,int blocking) {
    480524        rt_header_t *pkt_hdr = NULL;
    481525        void *void_hdr;
     526        libtrace_rt_types_t switch_type;
    482527       
    483528        if (packet->buf_control == TRACE_CTRL_PACKET) {
     
    506551        }
    507552        packet->type = RT_INFO->rt_hdr.type;
    508 
    509553       
    510554        if (packet->type >= TRACE_RT_DATA_SIMPLE) {
    511                 if (rt_read(libtrace,
    512                                         &packet->buffer,
    513                                         (size_t)RT_INFO->rt_hdr.length,
    514                                         blocking) != RT_INFO->rt_hdr.length) {
     555                switch_type = TRACE_RT_DATA_SIMPLE;
     556        } else {
     557                switch_type = packet->type;
     558        }
     559
     560        switch(switch_type) {
     561                case TRACE_RT_DATA_SIMPLE:
     562                case TRACE_RT_DUCK_2_4:
     563                case TRACE_RT_DUCK_2_5:
     564                case TRACE_RT_STATUS:
     565                case TRACE_RT_METADATA:
     566                        if (rt_read_data_packet(libtrace, packet, blocking))
     567                                return -1;
     568                        break;
     569                case TRACE_RT_END_DATA:
     570                case TRACE_RT_KEYCHANGE:
     571                case TRACE_RT_LOSTCONN:
     572                case TRACE_RT_CLIENTDROP:
     573                case TRACE_RT_SERVERSTART:
     574                        /* All these have no payload */
     575                        break;
     576                case TRACE_RT_PAUSE_ACK:
     577                        /* XXX: Add support for this */
     578                        break;
     579                case TRACE_RT_OPTION:
     580                        /* XXX: Add support for this */
     581                        break;
     582                default:
     583                        printf("Bad rt type for client receipt: %d\n",
     584                                        switch_type);
    515585                        return -1;
    516                 }
    517                 packet->header = packet->buffer;
     586        }
     587                               
     588                       
    518589               
    519                 if (RT_INFO->reliable > 0) {
    520                         if (rt_send_ack(libtrace, RT_INFO->rt_hdr.sequence)
    521                                         == -1)
    522                         {
    523                                 return -1;
    524                         }
    525                 }
    526                
    527                        
    528                 if (rt_set_format(libtrace, packet) < 0) {
    529                         return -1;
    530                 }
    531                 rt_set_payload(packet);
    532         } else {
    533                 switch(packet->type) {
    534                         case TRACE_RT_STATUS:
    535                         case TRACE_RT_METADATA:
    536                                 if (rt_read(libtrace, &packet->buffer,
    537                                         (size_t)RT_INFO->rt_hdr.length,
    538                                         blocking) !=
    539                                                 RT_INFO->rt_hdr.length) {
    540                                         return -1;
    541                                 }
    542                                 packet->header = 0;
    543                                 packet->payload = packet->buffer;
    544                                 break;
    545                         case TRACE_RT_DUCK_2_4:
    546                         case TRACE_RT_DUCK_2_5:
    547                                 if (rt_read(libtrace, &packet->buffer,
    548                                         (size_t)RT_INFO->rt_hdr.length,
    549                                         blocking) !=
    550                                                 RT_INFO->rt_hdr.length) {
    551                                         return -1;
    552                                 }
    553                                 if (rt_set_format(libtrace, packet) < 0) {
    554                                         return -1;
    555                                 }
    556                                 packet->header = 0;
    557                                 packet->payload = packet->buffer;
    558                                 break;
    559                         case TRACE_RT_END_DATA:
    560                                 break;
    561                         case TRACE_RT_PAUSE_ACK:
    562                                 /* FIXME: Do something useful */
    563                                 break;
    564                         case TRACE_RT_OPTION:
    565                                 /* FIXME: Do something useful here as well */
    566                                 break;
    567                         case TRACE_RT_KEYCHANGE:
    568                                 break;
    569                         case TRACE_RT_LOSTCONN:
    570                                 break;
    571                         case TRACE_RT_SERVERSTART:
    572                                 break;
    573                         case TRACE_RT_CLIENTDROP:
    574                                 break;
    575                         default:
    576                                 printf("Bad rt type for client receipt: %d\n",
    577                                         packet->type);
    578                                 return -1;
    579                 }
    580         }
    581590        /* Return the number of bytes read from the stream */
    582591        RT_INFO->rt_hdr.type = TRACE_RT_LAST;
     
    711720        NULL,                           /* fin_output */
    712721        rt_read_packet,                 /* read_packet */
     722        rt_prepare_packet,              /* prepare_packet */
    713723        NULL,                           /* fin_packet */
    714724        NULL,                           /* write_packet */
Note: See TracChangeset for help on using the changeset viewer.