Changeset eeab9832 for lib/format_erf.c


Ignore:
Timestamp:
03/03/06 18:24:18 (15 years ago)
Author:
Perry Lorier <perry@…>
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:
7ac9705
Parents:
c3e6e47
Message:

more error handling support
dag card work-around
removed annoying issue with mallocing memory during constructor that we

never free'd

added the ability to catch finalised packets

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/format_erf.c

    r30c0246 reeab9832  
    155155#ifdef HAVE_DAG
    156156static int dag_init_input(struct libtrace_t *libtrace) {
     157        struct stat buf;
     158
    157159        libtrace->format_data = (struct erf_format_data_t *)
    158160                malloc(sizeof(struct erf_format_data_t));
    159         return 0;
    160 }
    161 
    162 static int dag_start_input(struct libtrace_t *libtrace) {
    163         struct stat buf;
    164161        if (stat(libtrace->uridata, &buf) == -1) {
    165162                trace_set_err(libtrace,errno,"stat(%s)",libtrace->uridata);
     
    178175                        return -1;
    179176                }
    180                 if(dag_start(INPUT.fd) < 0) {
    181                         trace_set_err(libtrace,errno,"Cannot start DAG %s",
    182                                         libtrace->uridata);
    183                         return -1;
    184                 }
    185177        } else {
    186178                trace_set_err(libtrace,errno,"Not a valid dag device: %s",
     
    190182        return 0;
    191183}
     184
    192185#endif
    193186
     
    195188 * so that the ip header is aligned on a 32 bit boundary.
    196189 */
    197 static int erf_get_padding(const struct libtrace_packet_t *packet)
     190static int erf_get_padding(const libtrace_packet_t *packet)
    198191{
    199         switch(trace_get_link_type(packet)) {
    200                 case TRACE_TYPE_ETH:    return 2;
     192        dag_record_t *erfptr = (dag_record_t *)packet->header;
     193        switch(erfptr->type) {
     194                case TYPE_ETH:          return 2;
    201195                default:                return 0;
    202196        }
    203197}
    204198
    205 static int erf_get_framing_length(const struct libtrace_packet_t *packet)
     199static int erf_get_framing_length(const libtrace_packet_t *packet)
    206200{
    207201        return dag_record_size + erf_get_padding(packet);
     
    209203
    210204
    211 static int erf_init_input(struct libtrace_t *libtrace)
     205static int erf_init_input(libtrace_t *libtrace)
    212206{
    213207        libtrace->format_data = malloc(sizeof(struct erf_format_data_t));
     
    334328}
    335329
    336 static int rtclient_init_input(struct libtrace_t *libtrace) {
     330static int rtclient_init_input(libtrace_t *libtrace) {
    337331        char *scan;
    338332        libtrace->format_data = malloc(sizeof(struct erf_format_data_t));
     
    396390}
    397391
    398 static int erf_init_output(struct libtrace_out_t *libtrace) {
     392static int erf_init_output(libtrace_out_t *libtrace) {
    399393        libtrace->format_data = calloc(1,sizeof(struct erf_format_data_out_t));
    400394
     
    406400}
    407401
    408 static int erf_config_output(struct libtrace_out_t *libtrace, trace_option_t option, void *value) {
     402static int erf_config_output(libtrace_out_t *libtrace, trace_option_t option, void *value) {
    409403
    410404        switch (option) {
     
    425419
    426420#ifdef HAVE_DAG
    427 static int dag_fin_input(struct libtrace_t *libtrace) {
     421static int dag_pause_input(libtrace_t *libtrace) {
    428422        dag_stop(INPUT.fd);
     423        return 0; /* success */
     424}
     425
     426static int dag_fin_input(libtrace_t *libtrace) {
     427        /* dag pause input implicitly called to cleanup before this */
     428        dag_close(INPUT.fd);
    429429        free(libtrace->format_data);
    430 }
    431 #endif
    432 
    433 static int rtclient_fin_input(struct libtrace_t *libtrace) {
     430        return 0; /* success */
     431}
     432#endif
     433
     434static int rtclient_fin_input(libtrace_t *libtrace) {
    434435        free(CONNINFO.rt.hostname);
    435436        close(INPUT.fd);
     
    438439}
    439440
    440 static int erf_fin_input(struct libtrace_t *libtrace) {
     441static int erf_fin_input(libtrace_t *libtrace) {
    441442        LIBTRACE_CLOSE(INPUT.file);
    442443        free(libtrace->format_data);
     
    444445}
    445446
    446 static int erf_fin_output(struct libtrace_out_t *libtrace) {
     447static int erf_fin_output(libtrace_out_t *libtrace) {
    447448        LIBTRACE_CLOSE(OUTPUT.file);
    448449        free(libtrace->format_data);
     
    451452 
    452453#if HAVE_DAG
    453 static int dag_read(struct libtrace_t *libtrace, int block_flag) {
    454         int numbytes;
    455         static short lctr = 0;
    456         struct dag_record_t *erfptr = 0;
    457         int rlen;
     454static int dag_read(libtrace_t *libtrace, int block_flag) {
    458455
    459456        if (DAG.diff != 0)
     
    461458
    462459        DAG.bottom = DAG.top;
     460
    463461        DAG.top = dag_offset(
    464462                        INPUT.fd,
    465463                        &(DAG.bottom),
    466464                        block_flag);
    467         DAG.diff = DAG.top -
    468                 DAG.bottom;
    469 
    470         numbytes=DAG.diff;
     465
     466        DAG.diff = DAG.top - DAG.bottom;
     467
    471468        DAG.offset = 0;
    472         return numbytes;
    473 }
    474 #endif
    475 
    476 #if HAVE_DAG
     469        return DAG.diff;
     470}
     471
    477472/* FIXME: dag_read_packet shouldn't update the pointers, dag_fin_packet
    478473 * should do that.
    479474 */
    480 static int dag_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
     475static int dag_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    481476        int numbytes;
    482477        int size;
    483478        dag_record_t *erfptr;
    484         void *buffer = packet->buffer;
    485         void *buffer2 = buffer;
    486         int rlen;
    487479
    488480        if (packet->buf_control == TRACE_CTRL_PACKET) {
     
    494486        packet->type = RT_DATA_ERF;
    495487       
    496         if ((numbytes = dag_read(libtrace,0)) <= 0)
     488        if ((numbytes = dag_read(libtrace,0)) < 0)
    497489                return numbytes;
     490        assert(numbytes>0);
    498491
    499492        /*DAG always gives us whole packets */
    500         erfptr = (dag_record_t *) ((void *)DAG.buf +
     493        erfptr = (dag_record_t *) ((char *)DAG.buf +
    501494                        (DAG.bottom + DAG.offset));
    502495        size = ntohs(erfptr->rlen);
    503496
    504         if ( size  > LIBTRACE_PACKET_BUFSIZE) {
    505                 assert( size < LIBTRACE_PACKET_BUFSIZE);
    506         }
     497        assert( size >= dag_record_size );
     498        assert( size < LIBTRACE_PACKET_BUFSIZE);
    507499       
    508500        packet->buffer = erfptr;
     
    511503                packet->payload = NULL;
    512504        } else {
    513                 packet->payload = packet->buffer + erf_get_framing_length(packet);
     505                packet->payload = (char*)packet->buffer
     506                        + erf_get_framing_length(packet);
    514507        }
    515508
     
    517510        DAG.diff -= size;
    518511
    519         assert(DAG.diff >= 0);
    520 
    521512        return (size);
    522513}
     514
     515static int dag_start_input(libtrace_t *libtrace) {
     516        if(dag_start(INPUT.fd) < 0) {
     517                trace_set_err(libtrace,errno,"Cannot start DAG %s",
     518                                libtrace->uridata);
     519                return -1;
     520        }
     521        /* dags appear to have a bug where if you call dag_start after
     522         * calling dag_stop, and at least one packet has arrived, bad things
     523         * happen.  flush the memory hole
     524         */
     525        while(dag_read(libtrace,1)!=0)
     526                DAG.diff=0;
     527        return 0;
     528}
    523529#endif
    524530
    525 static int erf_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
     531static int erf_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    526532        int numbytes;
    527533        int size;
     
    572578}
    573579
    574 static int rtclient_read(struct libtrace_t *libtrace, void *buffer, size_t len) {
     580static int rtclient_read(libtrace_t *libtrace, void *buffer, size_t len) {
    575581        int numbytes;
    576582
     
    599605}
    600606
    601 static int rtclient_read_packet(struct libtrace_t *libtrace, struct libtrace_packet_t *packet) {
     607static int rtclient_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    602608        int numbytes = 0;
    603609        char buf[RP_BUFSIZE];
     
    618624       
    619625        do {
    620                 struct libtrace_packet_status status;
     626                libtrace_packet_status_t status;
    621627                int size;
    622628                if (tracefifo_out_available(libtrace->fifo) == 0
     
    771777}
    772778
    773 static libtrace_linktype_t erf_get_link_type(const struct libtrace_packet_t *packet) {
     779static libtrace_linktype_t erf_get_link_type(const libtrace_packet_t *packet) {
    774780        dag_record_t *erfptr = 0;
    775781        erfptr = (dag_record_t *)packet->header;
     
    777783}
    778784
    779 static int8_t erf_get_direction(const struct libtrace_packet_t *packet) {
     785static int8_t erf_get_direction(const libtrace_packet_t *packet) {
    780786        dag_record_t *erfptr = 0;
    781787        erfptr = (dag_record_t *)packet->header;
     
    783789}
    784790
    785 static int8_t erf_set_direction(const struct libtrace_packet_t *packet, int8_t direction) {
     791static int8_t erf_set_direction(const libtrace_packet_t *packet, int8_t direction) {
    786792        dag_record_t *erfptr = 0;
    787793        erfptr = (dag_record_t *)packet->header;
     
    790796}
    791797
    792 static uint64_t erf_get_erf_timestamp(const struct libtrace_packet_t *packet) {
     798static uint64_t erf_get_erf_timestamp(const libtrace_packet_t *packet) {
    793799        dag_record_t *erfptr = 0;
    794800        erfptr = (dag_record_t *)packet->header;
     
    796802}
    797803
    798 static int erf_get_capture_length(const struct libtrace_packet_t *packet) {
     804static int erf_get_capture_length(const libtrace_packet_t *packet) {
    799805        dag_record_t *erfptr = 0;
    800806        erfptr = (dag_record_t *)packet->header;
     
    802808}
    803809
    804 static int erf_get_wire_length(const struct libtrace_packet_t *packet) {
     810static int erf_get_wire_length(const libtrace_packet_t *packet) {
    805811        dag_record_t *erfptr = 0;
    806812        erfptr = (dag_record_t *)packet->header;
     
    808814}
    809815
    810 static size_t erf_set_capture_length(struct libtrace_packet_t *packet, size_t size) {
     816static size_t erf_set_capture_length(libtrace_packet_t *packet, size_t size) {
    811817        dag_record_t *erfptr = 0;
    812818        assert(packet);
     
    825831
    826832#ifdef HAVE_DAG
    827 struct libtrace_eventobj_t trace_event_dag(struct libtrace_t *trace, struct libtrace_packet_t *packet) {
    828         struct libtrace_eventobj_t event = {0,0,0.0,0};
     833libtrace_eventobj_t trace_event_dag(libtrace_t *trace, libtrace_packet_t *packet) {
     834        libtrace_eventobj_t event = {0,0,0.0,0};
    829835        int dag_fd;
    830836        int data;
     
    914920        erf_fin_output,                 /* fin_output */
    915921        erf_read_packet,                /* read_packet */
     922        NULL,                           /* fin_packet */
    916923        erf_write_packet,               /* write_packet */
    917924        erf_get_link_type,              /* get_link_type */
     
    930937        NULL,                           /* get_fd */
    931938        trace_event_trace,              /* trace_event */
    932         erf_help                        /* help */
     939        erf_help,                       /* help */
     940        NULL                            /* next pointer */
    933941};
    934942
     
    941949        NULL,                           /* config_input */
    942950        dag_start_input,                /* start_input */
    943         NULL,                           /* pause_input */
     951        dag_pause_input,                /* pause_input */
    944952        NULL,                           /* init_output */
    945953        NULL,                           /* config_output */
     
    948956        NULL,                           /* fin_output */
    949957        dag_read_packet,                /* read_packet */
     958        NULL,                           /* fin_packet */
    950959        NULL,                           /* write_packet */
    951960        erf_get_link_type,              /* get_link_type */
     
    964973        NULL,                           /* get_fd */
    965974        trace_event_dag,                /* trace_event */
    966         dag_help                        /* help */
     975        dag_help,                       /* help */
     976        NULL                            /* next pointer */
    967977};
    968978#endif
     
    982992        NULL,                           /* fin_output */
    983993        rtclient_read_packet,           /* read_packet */
     994        NULL,                           /* fin_packet */
    984995        NULL,                           /* write_packet */
    985996        erf_get_link_type,              /* get_link_type */
     
    9981009        rtclient_get_fd,                /* get_fd */
    9991010        trace_event_device,             /* trace_event */
    1000         rtclient_help                   /* help */
     1011        rtclient_help,                  /* help */
     1012        NULL                            /* next pointer */
    10011013};
    10021014
Note: See TracChangeset for help on using the changeset viewer.