generalize freelist return for txn, records and chunks, and test

src/data.c

@@ -199,15 +199,20 @@ DATA_Take_Free(chunk)
  * return to global freelist
  * returned must be locked by caller, if required
  */
-void
-DATA_Return_Freelist(struct txhead_s *returned, unsigned nreturned)
-{
-    AZ(pthread_mutex_lock(&freetx_lock));
-    VSTAILQ_CONCAT(&freetxhead, returned);
-    global_nfree_tx += nreturned;
-    AZ(pthread_mutex_unlock(&freetx_lock));
+#define DATA_Return_Free(type)                                          \
+void                                                                    \
+DATA_Return_Free##type(struct type##head_s *returned, unsigned nreturned) \
+{                                                                       \
+    AZ(pthread_mutex_lock(&free##type##_lock));                         \
+    VSTAILQ_CONCAT(&free##type##head, returned);                        \
+    global_nfree_##type += nreturned;                                   \
+    AZ(pthread_mutex_unlock(&free##type##_lock));                       \
 }
 
+DATA_Return_Free(tx)
+DATA_Return_Free(line)
+DATA_Return_Free(chunk)
+
 #define DUMP_HDRS(vsb, ll, hdr) do {                    \
     if (ll->hdr)                                        \
         for (j = 0; j < ll->hdr->nrec; j++)             \

src/test/test_data.c

@@ -161,13 +161,49 @@ static const char
 
     printf("... testing tx freelist return\n");
 
-    DATA_Return_Freelist(&local_freetx, config.max_data);
+    DATA_Return_Freetx(&local_freetx, config.max_data);
 
     MASSERT(VSTAILQ_EMPTY(&local_freetx));
     MASSERT(global_nfree_tx == config.max_data);
     /*MASSERT(!VSTAILQ_EMPTY(&freehead));*/
     VSTAILQ_FOREACH(tx, &local_freetx, freelist)
-        MCHECK_OBJ_NOTNULL(tx, LOGLINE_MAGIC);
+        MCHECK_OBJ_NOTNULL(tx, TX_MAGIC);
+
+    return NULL;
+}
+
+static const char
+*test_data_return_rec(void)
+{
+    logline_t *rec;
+
+    printf("... testing record freelist return\n");
+
+    DATA_Return_Freeline(&local_freeline, nrecords);
+
+    MASSERT(VSTAILQ_EMPTY(&local_freeline));
+    MASSERT(global_nfree_line == nrecords);
+    /*MASSERT(!VSTAILQ_EMPTY(&freehead));*/
+    VSTAILQ_FOREACH(rec, &local_freeline, freelist)
+        MCHECK_OBJ_NOTNULL(rec, LOGLINE_MAGIC);
+
+    return NULL;
+}
+
+static const char
+*test_data_return_chunk(void)
+{
+    chunk_t *chunk;
+
+    printf("... testing chunk freelist return\n");
+
+    DATA_Return_Freechunk(&local_freechunk, nchunks);
+
+    MASSERT(VSTAILQ_EMPTY(&local_freechunk));
+    MASSERT(global_nfree_chunk == nchunks);
+    /*MASSERT(!VSTAILQ_EMPTY(&freehead));*/
+    VSTAILQ_FOREACH(chunk, &local_freechunk, freelist)
+        MCHECK_OBJ_NOTNULL(chunk, CHUNK_MAGIC);
 
     return NULL;
 }
@@ -180,6 +216,8 @@ static const char
     mu_run_test(test_data_take_rec);
     mu_run_test(test_data_take_chunks);
     mu_run_test(test_data_return_tx);
+    mu_run_test(test_data_return_rec);
+    mu_run_test(test_data_return_chunk);
     return NULL;
 }
 

src/varnishevent.h

@@ -245,7 +245,9 @@ void DATA_Clear_Logline(tx_t *tx);
 unsigned DATA_Take_Freetx(struct txhead_s *dst);
 unsigned DATA_Take_Freeline(struct linehead_s *dst);
 unsigned DATA_Take_Freechunk(struct chunkhead_s *dst);
-void DATA_Return_Freelist(struct txhead_s *returned, unsigned nreturned);
+void DATA_Return_Freetx(struct txhead_s *returned, unsigned nreturned);
+void DATA_Return_Freeline(struct linehead_s *returned, unsigned nreturned);
+void DATA_Return_Freechunk(struct chunkhead_s *returned, unsigned nreturned);
 void DATA_Dump(void);
 
 /* writer.c */

src/writer.c

@@ -138,7 +138,7 @@ open_log(void)
 static inline void
 wrt_return_freelist(void)
 {
-    DATA_Return_Freelist(&wrt_freelist, wrt_nfree);
+    DATA_Return_Freetx(&wrt_freelist, wrt_nfree);
     LOG_Log(LOG_DEBUG, "Writer: returned %u to free list", wrt_nfree);
     wrt_nfree = 0;
     assert(VSTAILQ_EMPTY(&wrt_freelist));