Changeset 9e429e8 for lib

Timestamp:

09/19/14 15:40:01 (8 years ago)

Author:

Richard Sanger <rsangerarj@…>

Branches:

4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, 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:

11cf9b1

Parents:

d994324 (diff), ea602cd (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 remote-tracking branch 'upsteam/master' into develop

Conflicts:

README
lib/format_dpdk.c
lib/format_linux.c
lib/trace.c

Location:

lib

Files:

• Makefile.am (modified) (1 diff)
• format_bpf.c (modified) (2 diffs)
• format_dag24.c (modified) (2 diffs)
• format_dag25.c (modified) (10 diffs)
• format_dpdk.c (modified) (17 diffs)
• format_erf.c (modified) (1 diff)
• format_helper.c (modified) (2 diffs)
• format_linux.c (modified) (8 diffs)
• format_pcap.c (modified) (4 diffs)
• format_pcapfile.c (modified) (1 diff)
• format_rt.c (modified) (3 diffs)
• trace.c (modified) (4 diffs)

lib/Makefile.am

@@ -18 +18 @@
 DAGSOURCE=
 endif
-EXTRA_DIST=format_dag24.c format_dag25.c
+EXTRA_DIST=format_dag24.c format_dag25.c dpdk_libtrace.mk
 
 if HAVE_LLVM

lib/format_bpf.c

@@ -422 +422 @@
         packet->payload=(char *)buffer + BPFHDR(packet)->bh_hdrlen;
 
-        /*
-        if (libtrace->format_data == NULL) {
-                if (bpf_init_input(libtrace))
-                        return -1;
-        }
-        */
-
         return 0;
 }
@@ -439 +432 @@
 {
         uint32_t flags = 0;
+        fd_set readfds;
+        struct timeval tout;
+        int ret;
 
         packet->type = bpf_linktype_to_rt(FORMATIN(libtrace)->linktype);
+
+        while (FORMATIN(libtrace)->remaining <= 0) {
+                tout.tv_sec = 0;
+                tout.tv_usec = 500000;
+                FD_ZERO(&readfds);
+                FD_SET(FORMATIN(libtrace)->fd, &readfds);
+
+                ret = select(FORMATIN(libtrace)->fd + 1, &readfds, NULL,
+                                NULL, &tout);
+                if (ret < 0 && errno != EINTR) {
+                        trace_set_err(libtrace, errno, "select");
+                        return -1;
+                } else if (ret < 0) {
+                        continue;
+                }
+
+                if (FD_ISSET(FORMATIN(libtrace)->fd, &readfds)) {
+                        /* Packets are available, read into buffer */
+                        ret=read(FORMATIN(libtrace)->fd,
+                                FORMATIN(libtrace)->buffer,
+                                FORMATIN(libtrace)->buffersize);
+
+                        if (ret == -1) {
+                                trace_set_err(libtrace,errno,"Failed to read");
+                                return -1;
+                        }
+
+                        if (ret == 0) {
+                                /* EOF */
+                                return 0;
+                        }
+
+                        FORMATIN(libtrace)->remaining=ret;
+                        FORMATIN(libtrace)->bufptr=
+                                        FORMATIN(libtrace)->buffer;
+                        break;
+                }
+
+                /* Timed out -- check if we should halt */
+                if (libtrace_halt)
+                        return 0;
+        }
         
-        /* Read from the BPF interface into our capture buffer */
-        if (FORMATIN(libtrace)->remaining<=0) {
-                int ret;
-
-                ret=read(FORMATIN(libtrace)->fd,
-                        FORMATIN(libtrace)->buffer,
-                        FORMATIN(libtrace)->buffersize);
-
-                if (ret == -1) {
-                        trace_set_err(libtrace,errno,"Failed to read");
-                        return -1;
-                }
-
-                if (ret == 0) {
-                        /* EOF */
-                        return 0;
-                }
-
-                FORMATIN(libtrace)->remaining=ret;
-                FORMATIN(libtrace)->bufptr=
-                                FORMATIN(libtrace)->buffer;
-        }
-
         /* We do NOT want anything trying to free the memory the packet is
          * stored in */

lib/format_dag24.c

@@ -473 +473 @@
                         } else {
                                 /* Do not sleep - try to read another packet */
+                                trace->filtered_packets ++;
                                 continue;
                         }
@@ -483 +484 @@
                         trace_set_capture_length(packet, trace->snaplen);
                 }
-
+                trace->accepted_packets ++;
                 return event;
         } while (1);

lib/format_dag25.c

@@ -586 +586 @@
 
         zero.tv_sec = 0;
-        zero.tv_usec = 0;
+        zero.tv_usec = 10000;
         nopoll = zero;
 
@@ -992 +992 @@
                 /* Flags. Can't do this */
                 memset(&erfhdr.flags,1,sizeof(erfhdr.flags));
-                if (trace_get_direction(packet)!=~0U)
+                if (trace_get_direction(packet)!=(int)~0U)
                         erfhdr.flags.iface = trace_get_direction(packet);
 
@@ -1035 +1035 @@
         int numbytes = 0;
         uint32_t flags = 0;
+        struct timeval maxwait;
+        struct timeval pollwait;
+
+        pollwait.tv_sec = 0;
+        pollwait.tv_usec = 10000;
+        maxwait.tv_sec = 0;
+        maxwait.tv_usec = 250000;
 
         /* Check if we're due for a DUCK report */
@@ -1057 +1064 @@
                 packet->buffer = 0;
         }
+        
+        if (dag_set_stream_poll(FORMAT_DATA->device->fd, 
+                        FORMAT_DATA->dagstream, sizeof(dag_record_t), &maxwait, 
+                        &pollwait) == -1)
+        {
+                trace_set_err(libtrace, errno, "dag_set_stream_poll");
+                return -1;
+        }
+
 
         /* Grab a full ERF record */
@@ -1063 +1079 @@
                 if (numbytes < 0)
                         return numbytes;
-                if (numbytes < dag_record_size)
+                if (numbytes < dag_record_size) {
+                        if (libtrace_halt)
+                                return 0;
                         /* Block until we see a packet */
                         continue;
+                }
                 erfptr = dag_get_record(libtrace);
         } while (erfptr == NULL);
@@ -1086 +1105 @@
  * return a SLEEP event (as we cannot select on the DAG file descriptor).
  */
-static libtrace_eventobj_t trace_event_dag(libtrace_t *trace,
+static libtrace_eventobj_t trace_event_dag(libtrace_t *libtrace,
                                         libtrace_packet_t *packet) {
         libtrace_eventobj_t event = {0,0,0.0,0};
@@ -1092 +1111 @@
         int numbytes;
         uint32_t flags = 0;
+        struct timeval minwait;
+        
+        minwait.tv_sec = 0;
+        minwait.tv_usec = 10000;
+        
+        if (dag_set_stream_poll(FORMAT_DATA->device->fd, 
+                        FORMAT_DATA->dagstream, 0, &minwait, 
+                        &minwait) == -1)
+        {
+                trace_set_err(libtrace, errno, "dag_set_stream_poll");
+                event.type = TRACE_EVENT_TERMINATE;
+                return event;
+        }
 
         do {
@@ -1099 +1131 @@
                 /* Need to call dag_available so that the top pointer will get
                  * updated, otherwise we'll never see any data! */
-                numbytes = dag_available(trace);
+                numbytes = dag_available(libtrace);
 
                 /* May as well not bother calling dag_get_record if 
                  * dag_available suggests that there's no data */
                 if (numbytes != 0)
-                        erfptr = dag_get_record(trace);
+                        erfptr = dag_get_record(libtrace);
                 if (erfptr == NULL) {
                         /* No packet available - sleep for a very short time */
-                        event.type = TRACE_EVENT_SLEEP;
-                        event.seconds = 0.0001;
+                        if (libtrace_halt) {
+                                event.type = TRACE_EVENT_TERMINATE;
+                        } else {                        
+                                event.type = TRACE_EVENT_SLEEP;
+                                event.seconds = 0.0001;
+                        }
                         break;
                 }
-                if (dag_prepare_packet(trace, packet, erfptr, 
+                if (dag_prepare_packet(libtrace, packet, erfptr, 
                                         TRACE_RT_DATA_ERF, flags)) {
                         event.type = TRACE_EVENT_TERMINATE;
@@ -1125 +1161 @@
                  * trace_event() so we have to do it ourselves */
 
-                if (trace->filter) {
-                        if (trace_apply_filter(trace->filter, packet)) {
-                                event.type = TRACE_EVENT_PACKET;
-                        } else {
+                if (libtrace->filter) {
+                        int filtret = trace_apply_filter(libtrace->filter, 
+                                        packet);
+                        if (filtret == -1) {
+                                trace_set_err(libtrace, TRACE_ERR_BAD_FILTER,
+                                                "Bad BPF Filter");
+                                event.type = TRACE_EVENT_TERMINATE;
+                                break;
+                        }
+
+                        if (filtret == 0) {
                                 /* This packet isn't useful so we want to
                                  * immediately see if there is another suitable
@@ -1134 +1177 @@
                                  * a sleep event in this case, like we used to
                                  * do! */
+                                libtrace->filtered_packets ++;
                                 trace_clear_cache(packet);
                                 continue;
                         }
+                                
+                        event.type = TRACE_EVENT_PACKET;
                 } else {
                         event.type = TRACE_EVENT_PACKET;
                 }
 
-                if (trace->snaplen > 0) {
-                        trace_set_capture_length(packet, trace->snaplen);
+                if (libtrace->snaplen > 0) {
+                        trace_set_capture_length(packet, libtrace->snaplen);
                 }
+                libtrace->accepted_packets ++;
                 break;
         } while (1);

lib/format_dpdk.c

@@ -60 +60 @@
 #include <unistd.h>
 #include <endian.h>
+#include <string.h>
+
+/* We can deal with any minor differences by checking the RTE VERSION
+ * Typically DPDK backports some fixes (typically for building against
+ * newer kernels) to the older version of DPDK.
+ *
+ * These get released with the rX suffix. The following macros where added
+ * in these new releases.
+ *
+ * Below this is a log of version that required changes to the libtrace
+ * code (that we still attempt to support).
+ *
+ * Currently 1.5 to 1.7 is supported.
+ */
 #include <rte_eal.h>
+#include <rte_version.h>
+#ifndef RTE_VERSION_NUM
+#       define RTE_VERSION_NUM(a,b,c,d) ((a) << 24 | (b) << 16 | (c) << 8 | (d))
+#endif
+#ifndef RTE_VER_PATCH_RELEASE
+#       define RTE_VER_PATCH_RELEASE 0
+#endif
+#ifndef RTE_VERSION
+#       define RTE_VERSION RTE_VERSION_NUM(RTE_VER_MAJOR,RTE_VER_MINOR, \
+        RTE_VER_PATCH_LEVEL, RTE_VER_PATCH_RELEASE)
+#endif
+
+/* 1.6.0r2 :
+ *      rte_eal_pci_set_blacklist() is removed
+ *      device_list is renamed ot pci_device_list
+ *
+ * Replaced by:
+ *      rte_devargs (we can simply whitelist)
+ */
+#if RTE_VERSION <= RTE_VERSION_NUM(1, 6, 0, 1)
+#       define DPDK_USE_BLACKLIST 1
+#else
+#       define DPDK_USE_BLACKLIST 0
+#endif
+
+/*
+ * 1.7.0 :
+ *      rte_pmd_init_all is removed
+ *
+ * Replaced by:
+ *      Nothing, no longer needed
+ */
+#if RTE_VERSION < RTE_VERSION_NUM(1, 7, 0, 0)
+#       define DPDK_USE_PMD_INIT 1
+#else
+#       define DPDK_USE_PMD_INIT 0
+#endif
+
 #include <rte_per_lcore.h>
 #include <rte_debug.h>
@@ -207 +259 @@
     int nb_tx_buf; /* The number of packet buffers in the tx ring */
     struct rte_mempool * pktmbuf_pool; /* Our packet memory pool */
+#if DPDK_USE_BLACKLIST
     struct rte_pci_addr blacklist[BLACK_LIST_SIZE]; /* Holds our device blacklist */
+        unsigned int nb_blacklist; /* Number of blacklist items in are valid */
+#endif
     char mempool_name[MEMPOOL_NAME_LEN]; /* The name of the mempool that we are using */
-    unsigned int nb_blacklist; /* Number of blacklist items in are valid */
     uint8_t rss_key[40]; // This is the RSS KEY
 #if HAS_HW_TIMESTAMPS_82580
@@ -262 +316 @@
  * So blacklist all devices except the one that we wish to use so that 
  * the others can still be used as standard ethernet ports.
- */
-static void blacklist_devices(struct dpdk_format_data_t *format_data, struct rte_pci_addr *whitelist)
+ *
+ * @return 0 if successful, otherwise -1 on error.
+ */
+#if DPDK_USE_BLACKLIST
+static int blacklist_devices(struct dpdk_format_data_t *format_data, struct rte_pci_addr *whitelist)
 {
         struct rte_pci_device *dev = NULL;
@@ -287 +344 @@
 
         rte_eal_pci_set_blacklist(format_data->blacklist, format_data->nb_blacklist);
-}
+        return 0;
+}
+#else /* DPDK_USE_BLACKLIST */
+#include <rte_devargs.h>
+static int blacklist_devices(struct dpdk_format_data_t *format_data UNUSED, struct rte_pci_addr *whitelist)
+{
+        char pci_str[20] = {0};
+        snprintf(pci_str, sizeof(pci_str), PCI_PRI_FMT,
+                 whitelist->domain,
+                 whitelist->bus,
+                 whitelist->devid,
+                 whitelist->function);
+        if (rte_eal_devargs_add(RTE_DEVTYPE_WHITELISTED_PCI, pci_str) < 0) {
+                return -1;
+        }
+        return 0;
+}
+#endif
 
 /**
@@ -441 +515 @@
 
 
-static inline int dpdk_init_enviroment(char * uridata, struct dpdk_format_data_t * format_data,
+/**
+ * XXX This is very bad XXX
+ * But we have to do something to allow getopts nesting
+ * Luckly normally the format is last so it doesn't matter
+ * DPDK only supports modern systems so hopefully this
+ * will continue to work
+ */
+struct saved_getopts {
+        char *optarg;
+        int optind;
+        int opterr;
+        int optopt;
+};
+
+static void save_getopts(struct saved_getopts *opts) {
+        opts->optarg = optarg;
+        opts->optind = optind;
+        opts->opterr = opterr;
+        opts->optopt = optopt;
+}
+
+static void restore_getopts(struct saved_getopts *opts) {
+        optarg = opts->optarg;
+        optind = opts->optind;
+        opterr = opts->opterr;
+        optopt = opts->optopt;
+}
+
+static inline int dpdk_init_environment(char * uridata, struct dpdk_format_data_t * format_data,
                                         char * err, int errlen) {
     int ret; /* Returned error codes */
@@ -451 +553 @@
     int i;
     struct rte_config *cfg = rte_eal_get_configuration();
+        struct saved_getopts save_opts;
     
 #if DEBUG
@@ -457 +560 @@
     rte_set_log_level(RTE_LOG_WARNING);
 #endif
-    /* Using proc-type auto allows this to be either primary or secondary 
-     * Secondary allows two instances of libtrace to be used on different
-     * ports. However current version of DPDK doesn't support this on the
-     * same card (My understanding is this should work with two separate
-     * cards).
+    /*
+     * Using unique file prefixes mean separate memory is used, unlinking
+     * the two processes. However be careful we still cannot access a 
+     * port that already in use.
      * 
      * Using unique file prefixes mean separate memory is used, unlinking
@@ -518 +620 @@
     //snprintf(cpu_number, sizeof(cpu_number), "%x", 0x1 << (my_cpu - 1));
 
-        /* Give this a name */
+
+        /* Give the memory map a unique name */
         snprintf(mem_map, sizeof(mem_map), "libtrace-%d", (int) getpid());
     /* rte_eal_init it makes a call to getopt so we need to reset the 
      * global optind variable of getopt otherwise this fails */
+        save_getopts(&save_opts);
     optind = 1;
     if ((ret = rte_eal_init(argc, argv)) < 0) {
@@ -528 +632 @@
         return -1;
     }
-
+        restore_getopts(&save_opts);
     // These are still running but will never do anything with DPDK v1.7 we
     // should remove this XXX in the future
@@ -545 +649 @@
     dump_configuration();
 #endif
+
+#if DPDK_USE_PMD_INIT
     /* This registers all available NICs with Intel DPDK
      * These are not loaded until rte_eal_pci_probe() is called.
@@ -553 +659 @@
         return -1;
     }
+#endif
 
     /* Black list all ports besides the one that we want to use */
-    blacklist_devices(format_data, &use_addr);
+        if ((ret = blacklist_devices(format_data, &use_addr)) < 0) {
+                snprintf(err, errlen, "Intel DPDK - Whitelisting PCI device failed,"
+                         " are you sure the address is correct?: %s", strerror(-ret));
+                return -1;
+        }
 
     /* This loads DPDK drivers against all ports that are not blacklisted */
@@ -595 +706 @@
     FORMAT(libtrace)->promisc = -1;
     FORMAT(libtrace)->pktmbuf_pool = NULL;
+#if DPDK_USE_BLACKLIST
     FORMAT(libtrace)->nb_blacklist = 0;
+#endif
     FORMAT(libtrace)->paused = DPDK_NEVER_STARTED;
     FORMAT(libtrace)->mempool_name[0] = 0;
@@ -604 +717 @@
 #endif
         
-    if (dpdk_init_enviroment(libtrace->uridata, FORMAT(libtrace), err, sizeof(err)) != 0) {
+    if (dpdk_init_environment(libtrace->uridata, FORMAT(libtrace), err, sizeof(err)) != 0) {
         trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, "%s", err);
         free(libtrace->format_data);
@@ -628 +741 @@
     FORMAT(libtrace)->promisc = -1;
     FORMAT(libtrace)->pktmbuf_pool = NULL;
+#if DPDK_USE_BLACKLIST
     FORMAT(libtrace)->nb_blacklist = 0;
+#endif
     FORMAT(libtrace)->paused = DPDK_NEVER_STARTED;
     FORMAT(libtrace)->mempool_name[0] = 0;
@@ -637 +752 @@
 #endif
 
-    if (dpdk_init_enviroment(libtrace->uridata, FORMAT(libtrace), err, sizeof(err)) != 0) {
+    if (dpdk_init_environment(libtrace->uridata, FORMAT(libtrace), err, sizeof(err)) != 0) {
         trace_set_err_out(libtrace, TRACE_ERR_INIT_FAILED, "%s", err);
         free(libtrace->format_data);
@@ -815 +930 @@
 
     /* First time started we need to alloc our memory, doing this here 
-     * rather than in enviroment setup because we don't have snaplen then */
+     * rather than in environment setup because we don't have snaplen then */
     if (format_data->paused == DPDK_NEVER_STARTED) {
         if (format_data->snaplen == 0) {
@@ -1807 +1922 @@
                 if (!trace_apply_filter(trace->filter, packet)) {
                     /* Failed the filter so we loop for another packet */
+                    trace->filtered_packets ++;
                     continue;
                 }
             }
+            trace->accepted_packets ++;
         } else {
             /* We only want to sleep for a very short time - we are non-blocking */

lib/format_erf.c

@@ -746 +746 @@
          * we just need to read and return the next packet in the trace */
         if (IN_OPTIONS.real_time) {
-                event.size = erf_read_packet(libtrace, packet);
+                event.size = trace_read_packet(libtrace, packet);
                 if (event.size < 1)
                         event.type = TRACE_EVENT_TERMINATE;

lib/format_helper.c

@@ -98 +98 @@
          * solution. */
 
-        do {
+        do {
                 tv.tv_sec = 0;
                 tv.tv_usec = 0;
@@ -111 +111 @@
 
         if (FD_ISSET(event.fd, &rfds_param)) {
-                event.size = trace_read_packet(trace,packet);
-                
+                event.size = trace_read_packet(trace,packet);
                 if (event.size < 1) {
                         /* Covers error and EOF events - terminate rather 

lib/format_linux.c

@@ -546 +546 @@
          */
         if (filter != NULL) {
-                assert(filter->flag == 1);
+                /* Check if the filter was successfully compiled. If not,
+                 * it is probably a bad filter and we should return an error
+                 * before the caller tries to read any packets */
+                if (filter->flag == 0) {
+                        return -1;
+                }
+                
                 if (setsockopt(FORMAT(libtrace->format_data)->fd,
                                         SOL_SOCKET,
@@ -902 +908 @@
 
                 if (pcap_compile(pcap, &f->filter, f->filterstring, 0, 0) == -1) {
-                        perror("PCAP failed to compile the filterstring");
-                        return -1;
+                        /* Filter didn't compile, set flag to 0 so we can
+                         * detect this when trace_start() is called and
+                         * produce a useful error
+                         */
+                        f->flag = 0;
+                        trace_set_err(libtrace, TRACE_ERR_INIT_FAILED, 
+                                        "Failed to compile BPF filter (%s): %s",
+                                        f->filterstring, pcap_geterr(pcap));
+                } else {
+                        /* Set the "flag" to indicate that the filterstring 
+                         * has been compiled
+                         */
+                        f->flag = 1;
                 }
 
                 pcap_close(pcap);
                 
-                /* Set the "flag" to indicate that the filterstring has been
-                 * compiled
-                 */
-                f->flag = 1;
         }
         
@@ -1072 +1085 @@
 
         uint32_t flags = 0;
+        fd_set readfds;
+        struct timeval tout;
+        int ret;
         
         if (!packet->buffer || packet->buf_control == TRACE_CTRL_EXTERNAL) {
@@ -1118 +1134 @@
                         FD_SET(get_thread_table(libtrace)->messages.pipefd[0], &rfds);
                         int largestfd = fd > get_thread_table(libtrace)->messages.pipefd[0] ? fd : get_thread_table(libtrace)->messages.pipefd[0];
-                        
                         do {
                                 ret = select(largestfd+1, &rfds, NULL, NULL, NULL);
@@ -1136 +1151 @@
                 }
         } else {
-                hdr->wirelen = recvmsg(fd, &msghdr, MSG_TRUNC);
-        }
+        /* Use select to allow us to time out occasionally to check if someone
+         * has hit Ctrl-C or otherwise wants us to stop reading and return
+         * so they can exit their program.
+         */
+
+        while (1) {
+                tout.tv_sec = 0;
+                tout.tv_usec = 500000;
+                FD_ZERO(&readfds);
+                FD_SET(FORMAT(libtrace->format_data)->fd, &readfds);
+
+                ret = select(FORMAT(libtrace->format_data)->fd + 1, &readfds,
+                                NULL, NULL, &tout);
+                if (ret < 0 && errno != EINTR) {
+                        trace_set_err(libtrace, errno, "select");
+                        return -1;
+                } else if (ret < 0) {
+                        continue;
+                } 
+                
+                if (FD_ISSET(FORMAT(libtrace->format_data)->fd, &readfds)) {
+                        /* There's something available for us to read */
+                        break;
+                }
+
+                
+                /* If we get here, we timed out -- check if we should halt */
+                if (libtrace_halt)
+                        return 0;
+        }
+        hdr->wirelen = recvmsg(FORMAT(libtrace->format_data)->fd, &msghdr, MSG_TRUNC);
+        }
+
+                        
+                        
         
         if (hdr->wirelen==~0U) {
@@ -1288 +1336 @@
         assert((((unsigned long) header) & (pagesize - 1)) == 0);
 
-        /* TP_STATUS_USER means that we can use the frame.
-         * When a slot does not have this flag set, the frame is not
-         * ready for consumption.
-         */
-        while (!(header->tp_status & TP_STATUS_USER)) {
+        while (1) {
                 if (message) {
                         struct pollfd pollset[2];
@@ -1318 +1362 @@
 
                         /* Wait for more data or a message*/
-                        ret = poll(&pollset, 1, -1);
+                ret = poll(&pollset, 1, 500);
                         if (ret < 0) {
                                 if (errno != EINTR)
                                         trace_set_err(libtrace,errno,"poll()");
                                 return -1;
-                        }
+                } else if (ret == 0) {
+                        /* Poll timed out - check if we should exit */
+                        if (libtrace_halt)
+                                return 0;
+                        continue;
+                }
+
+                /* TP_STATUS_USER means that we can use the frame.
+                 * When a slot does not have this flag set, the frame is not
+                 * ready for consumption.
+                 */
+                if (header->tp_status & TP_STATUS_USER)
+                        break;
                 }
         }
@@ -1380 +1436 @@
         if(header->tp_status & TP_STATUS_USER){
                 /* We have a frame waiting */
-                event.size = linuxring_read_packet(libtrace, packet);
+                event.size = trace_read_packet(libtrace, packet);
                 event.type = TRACE_EVENT_PACKET;
         } else {

lib/format_pcap.c

@@ -295 +295 @@
         }
 #endif
+#ifdef HAVE_PCAP_SETNONBLOCK
+        pcap_setnonblock(INPUT.pcap,0,errbuf);
+#endif
         /* Set a filter if one is defined */
         if (DATA(libtrace)->filter) {
-                if (DATA(libtrace)->filter->flag == 0) {
+                struct pcap_pkthdr *pcap_hdr = NULL;
+                u_char *pcap_payload = NULL;
+                int pcapret;
+                
+                if (DATA(libtrace)->filter->flag == 0) {
                         pcap_compile(INPUT.pcap, 
                                         &DATA(libtrace)->filter->filter,
@@ -304 +311 @@
                         DATA(libtrace)->filter->flag = 1;
                 }
-                if (pcap_setfilter(INPUT.pcap,&DATA(libtrace)->filter->filter)
+                if (pcap_setfilter(INPUT.pcap,&DATA(libtrace)->filter->filter)
                         == -1) {
                         trace_set_err(libtrace,TRACE_ERR_INIT_FAILED,"%s",
@@ -310 +317 @@
                         return -1; /* failure */
                 }
-        }
-#ifdef HAVE_PCAP_SETNONBLOCK
-        pcap_setnonblock(INPUT.pcap,0,errbuf);
-#endif
+
+                /* Consume the first packet in the queue, as this may not
+                 * have had the filter applied to it.
+                 *
+                 * Otherwise we can get problems with the event API, where
+                 * select tells us that there is a packet available but
+                 * calling trace_read_packet will block forever because the
+                 * packet in the queue didn't match the filter so
+                 * pcap_next_ex returns "timed out".
+                 *
+                 * This does mean we may consume a legitimate packet, but
+                 * that's a pretty small downside compared with trace_event
+                 * getting stuck in an infinite loop because of pcap
+                 * wackiness. 
+                 *
+                 * For some reason, we only need to consume one packet for
+                 * this to work, so let's hope that holds in the future.
+                 */
+                do {
+                        pcapret = pcap_next_ex(INPUT.pcap, &pcap_hdr, 
+                                (const u_char **)&pcap_payload);
+                } while (0);
+
+                if (pcapret < 0)
+                        return -1;
+        }
         return 0; /* success */
 }
@@ -421 +450 @@
                                 if (libtrace_halt)
                                         return 0;
-                                continue; /* timeout expired */
+                                continue; /* timeout expired */
                         case -1: 
                                 trace_set_err(libtrace,TRACE_ERR_BAD_PACKET,

lib/format_pcapfile.c

@@ -713 +713 @@
 
         if (IN_OPTIONS.real_time) {
-                event.size = pcapfile_read_packet(libtrace, packet);
+                event.size = trace_read_packet(libtrace, packet);
                 if (event.size < 1)
                         event.type = TRACE_EVENT_TERMINATE;

lib/format_rt.c

@@ -780 +780 @@
                         if (packet->type == TRACE_RT_END_DATA)
                                 event.type = TRACE_EVENT_TERMINATE;
-                        else
+                        else {
                                 /* Since several RT messages can have zero-byte
                                  * length (once the framing is removed), an 
@@ -786 +786 @@
                                  * PACKET event */
                                 event.type = TRACE_EVENT_PACKET;
+                                trace->accepted_packets ++;
+                        }
 
                 }       
                 else {
                         event.type = TRACE_EVENT_PACKET;
+                        trace->accepted_packets ++;
                 }
 
@@ -795 +798 @@
                         if (!trace_apply_filter(trace->filter, packet)) {
                                 trace_clear_cache(packet);
-                                continue;
+                                trace->filtered_packets ++;
+                                continue;
                         }
                 }

lib/trace.c

@@ -825 +825 @@
                 do {
                         size_t ret;
+                        int filtret;
                         /* Finalise the packet, freeing any resources the format module
                          * may have allocated it and zeroing all data associated with it.
@@ -840 +841 @@
                                  * packet
                                  */
-                                if (!trace_apply_filter(libtrace->filter,packet)){
+                                filtret = trace_apply_filter(libtrace->filter, packet);
+                                if (filtret == -1) {
+                                        /* Error compiling filter, probably */
+                                        return ~0U;
+                                }
+                                
+                                if (filtret == 0) {
                                         ++libtrace->filtered_packets;
                                         continue;
@@ -1220 +1227 @@
 
         if (packet->trace->format->trace_event) {
+                /* Note: incrementing accepted, filtered etc. packet
+                 * counters is handled by the format-specific 
+                 * function so don't increment them here.
+                 */
                 event=packet->trace->format->trace_event(trace,packet);
-                if (event.type == TRACE_EVENT_PACKET) {
-                        ++trace->accepted_packets;
-                }
-        }
+                }
         return event;
 
@@ -1948 +1956 @@
                 return trace->format->get_filtered_packets(trace)+
                         trace->filtered_packets;
-        }
-        if (trace->format->get_received_packets
-                && trace->format->get_dropped_packets) {
-                return 
-                        ((trace_get_received_packets(trace)
-                        -trace_get_accepted_packets(trace))
-                        -trace_get_dropped_packets(trace))
-                        +trace->filtered_packets;
         }
         return trace->filtered_packets;