Changes in / [fdf23b8:d7d3267]


Ignore:
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • lib/format_etsilive.c

    r2193905 r2193905  
    7171        etsisocket_t *sources;
    7272        uint16_t sourcecount;
     73        uint16_t sourcealloc;
     74        uint16_t activesources;
    7375        int threadindex;
    7476        wandder_etsispec_t *etsidec;
     
    274276
    275277                FORMAT_DATA->receivers[i].sources = NULL;
     278                FORMAT_DATA->receivers[i].sourcealloc = 0;
    276279                FORMAT_DATA->receivers[i].sourcecount = 0;
     280                FORMAT_DATA->receivers[i].activesources = 0;
    277281                FORMAT_DATA->receivers[i].threadindex = i;
    278282                FORMAT_DATA->receivers[i].etsidec =
     
    331335                        != LIBTRACE_MQ_FAILED) {
    332336                etsisocket_t *esock = NULL;
     337                int i;
    333338
    334339                if (et->sourcecount == 0) {
    335340                        et->sources = (etsisocket_t *)malloc(
    336341                                        sizeof(etsisocket_t) * 10);
    337                 } else if ((et->sourcecount % 10) == 0) {
     342                        et->sourcealloc = 10;
     343
     344                        for (i = 0; i < et->sourcealloc; i++) {
     345                                et->sources[i].sock = -1;
     346                                et->sources[i].srcaddr = NULL;
     347                        }
     348
     349                        esock = &(et->sources[0]);
     350                        et->sourcecount = 1;
     351                } else {
     352                        for (i = 0; i < et->sourcealloc; i++) {
     353                                if (et->sources[i].sock == -1) {
     354                                        esock = &(et->sources[i]);
     355                                        break;
     356                                }
     357                        }
     358                }
     359
     360                if (esock == NULL) {
    338361                        et->sources = (etsisocket_t *)realloc(et->sources,
    339                                 sizeof(etsisocket_t) * (et->sourcecount + 10));
    340                 }
    341 
    342                 esock = &(et->sources[et->sourcecount]);
     362                                sizeof(etsisocket_t) * (et->sourcealloc + 10));
     363
     364                        esock = &(et->sources[et->sourcealloc]);
     365                        et->sourcealloc += 10;
     366                        et->sourcecount += 1;
     367
     368                }
     369
    343370                esock->sock = msg.recvsock;
    344371                esock->srcaddr = msg.recvaddr;
     
    348375                esock->cached.length = 0;
    349376
    350                 et->sourcecount += 1;
     377                et->activesources += 1;
    351378
    352379                fprintf(stderr, "Thread %d is now handling %u sources.\n",
    353                                 et->threadindex, et->sourcecount);
     380                                et->threadindex, et->activesources);
    354381        }
    355382        return 1;
    356383}
    357384
    358 static void receive_from_single_socket(etsisocket_t *esock) {
     385static void receive_from_single_socket(etsisocket_t *esock, etsithread_t *et) {
    359386
    360387        int ret = 0;
     
    366393        ret = libtrace_scb_recv_sock(&(esock->recvbuffer), esock->sock,
    367394                        MSG_DONTWAIT);
    368         if (ret == -1) {
     395        if (ret < 0) {
    369396                if (errno == EAGAIN || errno == EWOULDBLOCK) {
    370397                        /* Would have blocked, nothing available */
     
    375402                close(esock->sock);
    376403                esock->sock = -1;
     404                et->activesources -= 1;
    377405        }
    378406
     
    381409                close(esock->sock);
    382410                esock->sock = -1;
     411                et->activesources -= 1;
    383412        }
    384413
     
    399428        }
    400429
    401         if (et->sourcecount == 0) {
     430        if (et->activesources == 0) {
    402431                return 1;
    403432        }
    404433
    405434        for (i = 0; i < et->sourcecount; i++) {
    406                 receive_from_single_socket(&(et->sources[i]));
     435                receive_from_single_socket(&(et->sources[i]), et);
    407436        }
    408437        return 1;
     
    412441static inline void inspect_next_packet(etsisocket_t *sock,
    413442                etsisocket_t **earliestsock, uint64_t *earliesttime,
    414                 wandder_etsispec_t *dec) {
     443                wandder_etsispec_t *dec, etsithread_t *et) {
    415444
    416445
     
    465494                        close(sock->sock);
    466495                        sock->sock = -1;
     496                        et->activesources -= 1;
    467497                        return;
    468498                }
     
    472502                        close(sock->sock);
    473503                        sock->sock = -1;
     504                        et->activesources -= 1;
    474505                        return;
    475506                }
     
    510541        for (i = 0; i < et->sourcecount; i++) {
    511542                inspect_next_packet(&(et->sources[i]), &esock, &earliest,
    512                         et->etsidec);
     543                        et->etsidec, et);
    513544        }
    514545        return esock;
  • lib/format_helper.c

    r2193905 r2193905  
    226226        packet->buffer = trace->event.packet->buffer;
    227227        packet->buf_control = trace->event.packet->buf_control;
     228
     229        packet->which_trace_start = trace->event.packet->which_trace_start;
    228230
    229231        event.type = TRACE_EVENT_PACKET;
  • lib/format_linux_ring.c

    r2193905 r2193905  
    510510                                        libtrace_packet_t *packet,
    511511                                        struct linux_per_stream_t *stream,
    512                                         libtrace_message_queue_t *queue) {
     512                                        libtrace_message_queue_t *queue,
     513                                        uint8_t block) {
    513514
    514515        struct tpacket2_hdr *header;
     
    533534         */
    534535        while (!(header->tp_status & TP_STATUS_USER) ||
    535                header->tp_status == TP_STATUS_LIBTRACE) {
    536                 if ((ret=is_halted(libtrace)) != -1)
    537                         return ret;
     536                        header->tp_status == TP_STATUS_LIBTRACE) {
     537                if ((ret=is_halted(libtrace)) != -1)
     538                        return ret;
     539                if (!block) {
     540                        return 0;
     541                }
     542
    538543                pollset[0].fd = stream->fd;
    539544                pollset[0].events = POLLIN;
     
    617622
    618623static int linuxring_read_packet(libtrace_t *libtrace, libtrace_packet_t *packet) {
    619         return linuxring_read_stream(libtrace, packet, FORMAT_DATA_FIRST, NULL);
     624        return linuxring_read_stream(libtrace, packet, FORMAT_DATA_FIRST, NULL, 1);
    620625}
    621626
     
    624629                                   libtrace_thread_t *t,
    625630                                   libtrace_packet_t *packets[],
    626                                    UNUSED size_t nb_packets) {
    627         /* For now just read one packet */
    628         packets[0]->error = linuxring_read_stream(libtrace, packets[0],
    629                                                   t->format_data, &t->messages);
    630         if (packets[0]->error >= 1)
    631                 return 1;
    632         else
    633                 return packets[0]->error;
     631                                   size_t nb_packets) {
     632        size_t i;
     633        int ret;
     634
     635        for (i = 0; i < nb_packets; i++) {
     636                ret = linuxring_read_stream(libtrace, packets[i],
     637                                t->format_data, &t->messages, i == 0 ? 1 : 0);
     638                packets[i]->error = ret;
     639                if (ret < 0) {
     640                        return ret;
     641                }
     642
     643                if (ret == 0) {
     644                        if (is_halted(libtrace) == READ_EOF) {
     645                                return READ_EOF;
     646                        }
     647                        return i;
     648                }
     649        }
     650
     651        return nb_packets;
    634652}
    635653#endif
     
    672690        if (packet->buffer == NULL)
    673691                return;
     692<<<<<<< HEAD
     693        if (!libtrace) {
     694                return;
     695        }
     696=======
    674697        if (!packet->trace) {
    675698                fprintf(stderr, "Linux ring packet is not attached to a valid "
     
    677700                return;
    678701        }
     702>>>>>>> fdf23b83dbe8088f53ec27af98ec6ed7b71cc34d
    679703
    680704        /* If we own the packet (i.e. it's not a copy), we need to free it */
  • lib/trace.c

    r2193905 r2193905  
    22722272         * moving data around within this packet, so ordering is important.
    22732273         */
    2274         memmove(packet->payload, data, (size_t)len);
     2274        if (data != NULL) {
     2275                memmove(packet->payload, data, (size_t)len);
     2276        } else {
     2277                packet->payload = NULL;
     2278        }
    22752279        memmove(packet->header, &hdr, sizeof(hdr));
    22762280        packet->type=pcap_linktype_to_rt(libtrace_to_pcap_linktype(linktype));
  • tools/tracereplay/tracereplay.c

    rfdf23b8 rfdf23b8  
    9696        int i;
    9797
    98         if (IS_LIBTRACE_META_PACKET(packet))
     98        if (IS_LIBTRACE_META_PACKET(packet)) {
    9999                return NULL;
    100         if (trace_get_wire_length(packet) == 0)
     100        }
     101        if (trace_get_wire_length(packet) == 0) {
    101102                return NULL;
     103        }
    102104
    103105        pkt_buffer = trace_get_packet_buffer(packet,&linktype,&remaining);
     
    119121
    120122        trace_construct_packet(new_packet,linktype,pkt_buffer,wire_length);
    121 
    122123
    123124        if(broadcast) {
     
    174175                        case TRACE_EVENT_PACKET:
    175176                                /* Check for error first */
    176                                 if (obj.size == -1)
     177                                if (obj.size == -1) {
    177178                                        return -1;
     179                                }
    178180                                return 1;
    179181
  • tools/tracertstats/tracertstats.1

    r2e9df89 r54642da  
    1111[ -m | --merge-inputs ]
    1212[ -N | --nobuffer ]
     13[ -d | --report-drops ]
    1314inputuri...
    1415.P
     
    7576.TP
    7677.PD 0
     78.BI \-d
     79.TP
     80.PD
     81.BI \-\^\-report-drops
     82Include columns with the number of packets that were either dropped by the
     83capture process or went missing between the capture process and this
     84tracertstats instance. The numbers displayed are CUMULATIVE, as they are
     85pulled directly from the libtrace statistics API.
     86
     87.TP
     88.PD 0
    7789.BI \-o " format"
    7890.TP
  • tools/tracertstats/tracertstats.c

    r02d13cb r1800ee3  
    6666int filter_count=0;
    6767int burstsize=10;
     68uint8_t report_drops = 0;
    6869
    6970struct filter_t {
     
    9091}
    9192
    92 static void report_results(double ts,uint64_t count,uint64_t bytes)
     93static void report_results(double ts,uint64_t count,uint64_t bytes,
     94                libtrace_stat_t *stats)
    9395{
    94         int i=0;
     96        int i=0, offset = 3;
    9597        output_set_data_time(output,0,ts);
    9698        output_set_data_int(output,1,count);
    9799        output_set_data_int(output,2,bytes);
     100        if (stats) {
     101                if (stats->dropped_valid) {
     102                        output_set_data_int(output, 3, stats->dropped);
     103                } else {
     104                        output_set_data_int(output, 3, -1);
     105                }
     106                if (stats->missing_valid) {
     107                        output_set_data_int(output, 4, stats->missing);
     108                } else {
     109                        output_set_data_int(output, 4, -1);
     110                }
     111                offset += 2;
     112        }
    98113        for(i=0;i<filter_count;++i) {
    99                 output_set_data_int(output,i*2+3,filters[i].count);
    100                 output_set_data_int(output,i*2+4,filters[i].bytes);
     114                output_set_data_int(output,i*2+offset,filters[i].count);
     115                output_set_data_int(output,i*2+offset+1,filters[i].bytes);
    101116                filters[i].count=filters[i].bytes=0;
    102117        }
     
    115130        output_add_column(output,"packets");
    116131        output_add_column(output,"bytes");
     132        if (report_drops) {
     133                output_add_column(output, "dropped");
     134                output_add_column(output, "missing");
     135        }
    117136        for(i=0;i<filter_count;++i) {
    118137                char buff[1024];
     
    145164        int j;
    146165        result_t *res;
     166        libtrace_stat_t *stats = NULL;
    147167
    148168        if (stopped)
     
    153173        if (glob_last_ts == 0)
    154174                glob_last_ts = ts;
     175        if (report_drops) {
     176                stats = trace_create_statistics();
     177                trace_get_statistics(trace, stats);
     178        }
    155179        while ((glob_last_ts >> 32) < (ts >> 32)) {
    156                 report_results(glob_last_ts >> 32, count, bytes);
     180                report_results(glob_last_ts >> 32, count, bytes, stats);
    157181                count = 0;
    158182                bytes = 0;
     
    169193        }
    170194        free(res);
     195        if (stats) {
     196                free(stats);
     197        }
    171198
    172199        /* Be careful to only call pstop once from within this thread! */
     
    261288        libtrace_t *trace = NULL;
    262289        libtrace_callback_set_t *pktcbs, *repcbs;
     290        libtrace_stat_t *stats = NULL;
    263291
    264292        if (!merge_inputs)
     
    312340       
    313341        // Flush the last one out
    314         report_results((glob_last_ts >> 32), count, bytes);
     342        if (report_drops) {
     343                stats = trace_create_statistics();
     344                stats = trace_get_statistics(trace, stats);
     345        }
     346        report_results((glob_last_ts >> 32), count, bytes, stats);
    315347        if (trace_is_err(trace))
    316348                trace_perror(trace,"%s",uri);
    317349
     350        if (stats) {
     351                free(stats);
     352        }
    318353        trace_destroy(trace);
    319354        trace_destroy_callback_set(pktcbs);
     
    338373        "-N --nobuffer          Disable packet buffering within libtrace to force faster\n"
    339374        "                       updates at very low traffic rates\n"
     375        "-d --report-drops      Include statistics about number of packets dropped or\n"
     376        "                       lost by the capture process\n"
    340377        "-h --help      Print this usage statement\n"
    341378        ,argv0);
     
    358395                        { "threads",            1, 0, 't' },
    359396                        { "nobuffer",           0, 0, 'N' },
     397                        { "report-drops",       0, 0, 'd' },
    360398                        { NULL,                 0, 0, 0   },
    361399                };
    362400
    363                 int c=getopt_long(argc, argv, "c:f:i:o:t:hmN",
     401                int c=getopt_long(argc, argv, "c:f:i:o:t:dhmN",
    364402                                long_options, &option_index);
    365403
     
    368406
    369407                switch (c) {
     408                        case 'd':
     409                                report_drops = 1;
     410                                break;
    370411                        case 'N':
    371412                                burstsize = 1;
Note: See TracChangeset for help on using the changeset viewer.