Changeset 73a5b72


Ignore:
Timestamp:
09/20/18 16:12:42 (2 years ago)
Author:
Shane Alcock <salcock@…>
Branches:
develop, master, ringperformance
Children:
6a2f037
Parents:
6646938 (diff), 86087c53 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'ringdecrementfix' into develop

Location:
lib
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • lib/format_linux_common.c

    r47d4f8c rebed638  
    232232                close(stream->fd);
    233233        stream->fd = -1;
    234         if (stream->rx_ring != MAP_FAILED)
    235                 munmap(stream->rx_ring,
    236                        stream->req.tp_block_size *
    237                        stream->req.tp_block_nr);
    238         stream->rx_ring = MAP_FAILED;
    239         stream->rxring_offset = 0;
    240234        FORMAT_DATA->dev_stats.if_name[0] = 0;
     235
     236        /* Don't munmap the rx_ring here -- keep it around as long as
     237         * possible to ensure that any packets that the user is still
     238         * holding references to remain valid.
     239         *
     240         * Don't worry, linuxring will munmap the rx_ring as soon as
     241         * someone either destroys or restarts the trace. At that point,
     242         * any remaining packets from the old ring will be recognisable
     243         * as invalid.
     244         */
    241245}
    242246
  • lib/format_linux_ring.c

    r8a63abd rebed638  
    252252        char error[2048];
    253253
     254        /* Unmap any previous ring buffers associated with this stream. */
     255        if (stream->rx_ring != MAP_FAILED) {
     256                munmap(stream->rx_ring, stream->req.tp_block_size *
     257                                stream->req.tp_block_nr);
     258                stream->rx_ring = MAP_FAILED;
     259                stream->rxring_offset = 0;
     260        }
     261
     262
    254263        /* We set the socket up the same and then convert it to PACKET_MMAP */
    255264        if (linuxcommon_start_input_stream(libtrace, stream) < 0)
     
    274283        return 0;
    275284}
     285
     286static int linuxring_fin_input(libtrace_t *libtrace) {
     287        size_t i;
     288
     289        if (libtrace->format_data) {
     290                for (i = 0; i < libtrace_list_get_size(FORMAT_DATA->per_stream); ++i) {
     291                        struct linux_per_stream_t *stream;
     292                        stream = libtrace_list_get_index(
     293                                FORMAT_DATA->per_stream, i)->data;
     294                        if (stream->rx_ring != MAP_FAILED) {
     295                                munmap(stream->rx_ring,
     296                                                stream->req.tp_block_size *
     297                                                stream->req.tp_block_nr);
     298                        }
     299                }
     300
     301                if (FORMAT_DATA->filter != NULL)
     302                        free(FORMAT_DATA->filter);
     303
     304                if (FORMAT_DATA->per_stream)
     305                        libtrace_list_deinit(FORMAT_DATA->per_stream);
     306
     307                free(libtrace->format_data);
     308        }
     309
     310        return 0;
     311}
     312
    276313
    277314static int linuxring_start_input(libtrace_t *libtrace)
     
    622659        /* If we own the packet (i.e. it's not a copy), we need to free it */
    623660        if (packet->buf_control == TRACE_CTRL_EXTERNAL) {
    624                 /* Started should always match the existence of the rx_ring
    625                  * in the parallel case still just check the first ring */
    626                 assert(!!FORMAT_DATA_FIRST->rx_ring ==
    627                        !!packet->trace->started);
    628661                /* If we don't have a ring its already been destroyed */
    629662                if (FORMAT_DATA_FIRST->rx_ring != MAP_FAILED)
     
    742775        NULL,                           /* config_output */
    743776        linuxring_start_output,         /* start_ouput */
    744         linuxcommon_fin_input,          /* fin_input */
     777        linuxring_fin_input,            /* fin_input */
    745778        linuxring_fin_output,           /* fin_output */
    746779        linuxring_read_packet,          /* read_packet */
  • lib/format_pcap.c

    r32ee9b2 r37ee856  
    500500        /* Silently discard RT metadata packets and packets with an
    501501         * unknown linktype. */
    502         if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_ERF_META) {
     502        if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_ERF_META || linktype == TRACE_TYPE_CONTENT_INVALID) {
    503503                return 0;
    504504        }
     
    595595        /* Silently discard RT metadata packets and packets with an
    596596         * unknown linktype. */
    597         if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_ERF_META) {
     597        if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_ERF_META || linktype == TRACE_TYPE_CONTENT_INVALID) {
    598598                return 0;
    599599        }
  • lib/format_pcapfile.c

    r32ee9b2 r37ee856  
    432432        /* Silently discard RT metadata packets and packets with an
    433433         * unknown linktype. */
    434         if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_ERF_META) {
     434        if (linktype == TRACE_TYPE_NONDATA || linktype == TRACE_TYPE_UNKNOWN || linktype == TRACE_TYPE_ERF_META || linktype == TRACE_TYPE_CONTENT_INVALID) {
    435435                return 0;
    436436        }
  • lib/libtrace.h.in

    r47d4f8c r37ee856  
    347347
    348348/** Enumeration of link layer types supported by libtrace */
    349 typedef enum {
     349typedef enum {
     350       TRACE_TYPE_CONTENT_INVALID = -2, /**< Packet contents are not valid */
    350351       TRACE_TYPE_UNKNOWN = -1,         /**< Unable to determine link type */
    351352    /* TRACE_TYPE_LEGACY = 0            Obsolete */
     
    567568        pthread_mutex_t ref_lock;       /**< Lock for reference counter */
    568569        int refcount;                 /**< Reference counter */
     570        int which_trace_start;          /**< Used to match packet to a started instance of the parent trace */
    569571
    570572} libtrace_packet_t;
  • lib/libtrace_int.h

    r823d8e1 r37ee856  
    337337        /** Boolean flag indicating whether the trace has been started */
    338338        bool started;
     339        /** Number of times this trace has been started */
     340        int startcount;
    339341        /** Synchronise writes/reads across this format object and attached threads etc */
    340342        pthread_mutex_t libtrace_lock;
  • lib/linktypes.c

    rb663d33 r91bd90e  
    112112                        break;
    113113                case TRACE_TYPE_UNKNOWN:
     114                case TRACE_TYPE_CONTENT_INVALID:
    114115                        break;
    115116        }
     
    214215                case TRACE_TYPE_ETSILI:
    215216                case TRACE_TYPE_UNKNOWN:
     217                case TRACE_TYPE_CONTENT_INVALID:
    216218                        break;
    217219        }
     
    333335        struct timeval tv;
    334336        static libtrace_t *trace = NULL;
     337
    335338        switch(trace_get_link_type(packet)) {
    336339                case TRACE_TYPE_ATM:
     
    371374                        }
    372375
     376                        trace->startcount = packet->trace->startcount;
    373377                        packet->trace=trace;
    374378
  • lib/protocols_l2.c

    rfa555ec r37ee856  
    486486                        break;
    487487                case TRACE_TYPE_UNKNOWN:
     488                case TRACE_TYPE_CONTENT_INVALID:
    488489                        return NULL;
    489490        }
     
    523524                                        break;
    524525                                case TRACE_TYPE_UNKNOWN:
     526                                case TRACE_TYPE_CONTENT_INVALID:
    525527                                        return NULL;
    526528                        }
     
    565567        void *l;
    566568
    567         if (linktype == TRACE_TYPE_UNKNOWN) {
     569        if (linktype == TRACE_TYPE_UNKNOWN ||
     570                        linktype == TRACE_TYPE_CONTENT_INVALID) {
    568571                fprintf(stderr, "Unable to determine linktype for packet\n");
    569572                return NULL;
     
    589592                case TRACE_TYPE_NONDATA:
    590593                case TRACE_TYPE_ERF_META:
     594                case TRACE_TYPE_CONTENT_INVALID:
    591595                case TRACE_TYPE_UNKNOWN:
    592596                        return NULL;
     
    693697                case TRACE_TYPE_ERF_META:
    694698                case TRACE_TYPE_UNKNOWN:
     699                case TRACE_TYPE_CONTENT_INVALID:
    695700                        return NULL;
    696701
     
    744749                case TRACE_TYPE_ERF_META:
    745750                case TRACE_TYPE_UNKNOWN:
     751                case TRACE_TYPE_CONTENT_INVALID:
    746752                        /* No MAC address */
    747753                        return NULL;
  • lib/protocols_pktmeta.c

    r59b2ed8 r37ee856  
    186186                case TRACE_TYPE_OPENBSD_LOOP:
    187187                case TRACE_TYPE_UNKNOWN:
     188                case TRACE_TYPE_CONTENT_INVALID:
    188189                        return NULL;
    189190        }
     
    249250                case TRACE_TYPE_ERF_META:
    250251                case TRACE_TYPE_UNKNOWN:
     252                case TRACE_TYPE_CONTENT_INVALID:
    251253                        /* In this case, the pointer passed in does not point
    252254                         * to a metadata header and so we cannot get the
  • lib/trace.c

    rc862ad1 r86087c53  
    265265        libtrace->replayspeedup = 1;
    266266        libtrace->started=false;
     267        libtrace->startcount=0;
    267268        libtrace->uridata = NULL;
    268269        libtrace->io = NULL;
     
    534535                }
    535536        }
    536 
     537        libtrace->startcount ++;
    537538        libtrace->started=true;
    538539        return 0;
     
    840841
    841842        packet->buf_control=TRACE_CTRL_PACKET;
     843        packet->which_trace_start = 0;
    842844        pthread_mutex_init(&(packet->ref_lock), NULL);
    843845        trace_clear_cache(packet);
     
    846848
    847849DLLEXPORT libtrace_packet_t *trace_copy_packet(const libtrace_packet_t *packet) {
    848         libtrace_packet_t *dest =
    849                 (libtrace_packet_t *)calloc((size_t)1, sizeof(libtrace_packet_t));
     850        libtrace_packet_t *dest;
     851
     852        if (packet->which_trace_start != packet->trace->startcount) {
     853                return NULL;
     854        }
     855
     856        dest = (libtrace_packet_t *)calloc((size_t)1, sizeof(libtrace_packet_t));
    850857        if (!dest) {
    851858                printf("Out of memory constructing packet\n");
     
    866873        dest->hash = packet->hash;
    867874        dest->error = packet->error;
     875        dest->which_trace_start = packet->which_trace_start;
    868876        /* Reset the cache - better to recalculate than try to convert
    869877         * the values over to the new packet */
     
    10111019                                trace_packet_set_order(packet, libtrace->sequence_number);
    10121020                        }
     1021                        packet->which_trace_start = libtrace->startcount;
    10131022                        ++libtrace->sequence_number;
    10141023                        if (!libtrace_parallel && packet->trace == libtrace)
     
    11051114        int cap_len;
    11061115        int wire_len;
     1116        libtrace_linktype_t ltype;
    11071117
    11081118        assert(packet != NULL);
    1109         if (linktype) *linktype = trace_get_link_type(packet);
     1119        ltype = trace_get_link_type(packet);
     1120
     1121        if (linktype) {
     1122                *linktype = ltype;
     1123        }
     1124
     1125        if (ltype == TRACE_TYPE_CONTENT_INVALID) {
     1126                if (remaining) {
     1127                        *remaining = 0;
     1128                }
     1129                return NULL;
     1130        }
     1131
    11101132        if (remaining) {
    11111133                /* I think we should choose the minimum of the capture and
     
    11601182 */
    11611183DLLEXPORT uint64_t trace_get_erf_timestamp(const libtrace_packet_t *packet) {
     1184        if (packet->which_trace_start != packet->trace->startcount) {
     1185                return (uint64_t)0;
     1186        }
     1187
    11621188        if (packet->trace->format->get_erf_timestamp) {
    11631189                /* timestamp -> timestamp */
     
    11961222        struct timeval tv;
    11971223        uint64_t ts = 0;
    1198         if (packet->trace->format->get_timeval) {
     1224
     1225        if (packet->which_trace_start != packet->trace->startcount) {
     1226                tv.tv_sec=-1;
     1227                tv.tv_usec=-1;
     1228        } else if (packet->trace->format->get_timeval) {
    11991229                /* timeval -> timeval */
    12001230                tv = packet->trace->format->get_timeval(packet);
     
    12291259        struct timespec ts;
    12301260
    1231         if (packet->trace->format->get_timespec) {
     1261        if (packet->which_trace_start != packet->trace->startcount) {
     1262                ts.tv_sec=-1;
     1263                ts.tv_nsec=-1;
     1264        } else if (packet->trace->format->get_timespec) {
    12321265                return packet->trace->format->get_timespec(packet);
    12331266        } else if (packet->trace->format->get_erf_timestamp) {
     
    12401273                        ts.tv_sec += 1;
    12411274                }
    1242                 return ts;
    12431275        } else if (packet->trace->format->get_timeval) {
    12441276                /* timeval -> timespec */
     
    12461278                ts.tv_sec = tv.tv_sec;
    12471279                ts.tv_nsec = tv.tv_usec*1000;
    1248                 return ts;
    12491280        } else if (packet->trace->format->get_seconds) {
    12501281                /* seconds -> timespec */
     
    12521283                ts.tv_sec = (uint32_t)seconds;
    12531284                ts.tv_nsec = (long)(((seconds - ts.tv_sec) * 1000000000)/UINT_MAX);
    1254                 return ts;
    12551285        }
    12561286        else {
    12571287                ts.tv_sec=-1;
    12581288                ts.tv_nsec=-1;
    1259                 return ts;
    1260         }
     1289        }
     1290        return ts;
    12611291}
    12621292
     
    12681298DLLEXPORT double trace_get_seconds(const libtrace_packet_t *packet) {
    12691299        double seconds = 0.0;
     1300
     1301        if (packet->which_trace_start != packet->trace->startcount) {
     1302                return 0.0;
     1303        }
    12701304
    12711305        if (packet->trace->format->get_seconds) {
     
    12951329{
    12961330        /* Cache the capture length */
     1331        if (packet->which_trace_start != packet->trace->startcount) {
     1332                return ~0U;
     1333        }
    12971334        if (packet->capture_length == -1) {
    12981335                if (!packet->trace->format->get_capture_length)
     
    13171354DLLEXPORT size_t trace_get_wire_length(const libtrace_packet_t *packet){
    13181355
     1356        if (packet->which_trace_start != packet->trace->startcount) {
     1357                return ~0U;
     1358        }
     1359
    13191360        if (packet->wire_length == -1) {
    13201361                if (!packet->trace->format->get_wire_length)
     
    13371378DLLEXPORT SIMPLE_FUNCTION
    13381379size_t trace_get_framing_length(const libtrace_packet_t *packet) {
     1380        if (packet->which_trace_start != packet->trace->startcount) {
     1381                return ~0U;
     1382        }
     1383
    13391384        if (packet->trace->format->get_framing_length) {
    13401385                return packet->trace->format->get_framing_length(packet);
     
    13491394 */
    13501395DLLEXPORT libtrace_linktype_t trace_get_link_type(const libtrace_packet_t *packet ) {
     1396
     1397        if (packet->which_trace_start != packet->trace->startcount) {
     1398                return TRACE_TYPE_CONTENT_INVALID;
     1399        }
    13511400
    13521401        if (packet->link_type == 0) {
     
    16661715{
    16671716        assert(packet);
     1717        if (packet->which_trace_start != packet->trace->startcount) {
     1718                return (libtrace_direction_t)~0U;
     1719        }
    16681720        if (packet->trace->format->get_direction) {
    16691721                return packet->trace->format->get_direction(packet);
     
    23562408        packet->l4_remaining = 0;
    23572409        packet->refcount = 0;
    2358 
    23592410}
    23602411
  • lib/trace_parallel.c

    reeabc19b r37ee856  
    13451345                                return -1;
    13461346                        }
     1347                        packets[i]->which_trace_start = libtrace->startcount;
    13471348                }
    13481349                do {
     
    14601461        if (err == 0) {
    14611462                libtrace->started = true;
     1463                libtrace->startcount ++;
    14621464                libtrace_change_state(libtrace, STATE_RUNNING, false);
    14631465        }
     
    18631865        /* Threads don't start */
    18641866        libtrace->started = true;
     1867        libtrace->startcount ++;
    18651868        libtrace_change_state(libtrace, STATE_RUNNING, false);
    18661869
Note: See TracChangeset for help on using the changeset viewer.