Changeset c1205bd

Timestamp:

03/09/18 16:46:26 (3 years ago)

Author:

Shane Alcock <salcock@…>

Branches:

cachetimestamps, develop, etsilive, master, rc-4.0.4, ringdecrementfix, ringperformance

Children:

7c33187

Parents:

62ee4ec

Message:

Add packet reference counting API

This API allows users to keep track of references to libtrace
packet structures that are not being released by the per packet
processing threads, e.g. those passed to the reporter or to
any user-created pthreads.

If you only have one reference to a packet at any given time,
you won't need this API. However, if you have multiple
concurrent references, this API will allow you to ensure that the
packet is correctly freed only once all references have been
finished with.

Location:

lib

Files:

• libtrace.h.in (modified) (2 diffs)
• libtrace_parallel.h (modified) (1 diff)
• trace.c (modified) (3 diffs)
• trace_parallel.c (modified) (1 diff)

lib/libtrace.h.in

@@ -560 +560 @@
         uint64_t internalid;            /** Internal identifier for the pkt */
         void *srcbucket;
+
+        pthread_mutex_t ref_lock;       /**< Lock for reference counter */
+        int refcount;                 /**< Reference counter */
+
 } libtrace_packet_t;
 
@@ -1775 +1779 @@
 DLLEXPORT void trace_destroy_packet(libtrace_packet_t *packet);
 
-
 /** Read the next packet from an input trace 
  *

lib/libtrace_parallel.h

@@ -1272 +1272 @@
 DLLEXPORT void trace_free_packet(libtrace_t * libtrace, libtrace_packet_t * packet);
 
+/** Increments the internal reference counter for a packet.
+ * @param packet        The packet opaque pointer
+ *
+ * You may wish to use this function (and its decrementing counterpart)
+ * in situations where you are retaining multiple references to a packet
+ * outside of the core packet processing function. This will ensure that
+ * the packet is not released until there are no more outstanding references
+ * to the packet anywhere in your program.
+ */
+DLLEXPORT void trace_increment_packet_refcount(libtrace_packet_t *packet);
+
+/** Decrements the internal reference counter for a packet.
+ * @param packet        The packet opaque pointer
+ *
+ * If the reference counter goes below one, trace_fin_packet() will be
+ * called on the packet.
+ *
+ * You may wish to use this function (and its incrementing counterpart)
+ * in situations where you are retaining multiple references to a packet
+ * outside of the core packet processing function. This will ensure that
+ * the packet is not released until there are no more outstanding references
+ * to the packet anywhere in your program.
+ */
+DLLEXPORT void trace_decrement_packet_refcount(libtrace_packet_t *packet);
+
+
 /** Provides some basic information about a trace based on its input format.
  *

lib/trace.c

@@ -805 +805 @@
 
         packet->buf_control=TRACE_CTRL_PACKET;
+        pthread_mutex_init(&(packet->ref_lock), NULL);
         trace_clear_cache(packet);
         return packet;
@@ -856 +857 @@
                 free(packet->buffer);
         }
+        pthread_mutex_destroy(&(packet->ref_lock));
         packet->buf_control=(buf_control_t)'\0';
                                 /* A "bad" value to force an assert
@@ -2316 +2318 @@
         packet->l3_remaining = 0;
         packet->l4_remaining = 0;
+        packet->refcount = 0;
 
 }

lib/trace_parallel.c

@@ -2601 +2601 @@
 }
 
+DLLEXPORT void trace_increment_packet_refcount(libtrace_packet_t *packet) {
+        pthread_mutex_lock(&(packet->ref_lock));
+        if (packet->refcount < 0) {
+                packet->refcount = 1;
+        } else {
+                packet->refcount ++;
+        }
+        pthread_mutex_unlock(&(packet->ref_lock));
+}
+
+DLLEXPORT void trace_decrement_packet_refcount(libtrace_packet_t *packet) {
+        pthread_mutex_lock(&(packet->ref_lock));
+        packet->refcount --;
+
+        if (packet->refcount <= 0) {
+                trace_free_packet(packet->trace, packet);
+        }
+        pthread_mutex_unlock(&(packet->ref_lock));
+}
+
+
 DLLEXPORT libtrace_info_t *trace_get_information(libtrace_t * libtrace) {
         if (libtrace->format)