Fix over-freeing in internal object cache

When returning item to the cache and the items allocated exceeded cache->limit, we should free the item and not put it to the cache.

The current code will free any item that tried returned to the cache when cache->total < cache->limit which is true in most cases if the total objects has never exceeded the limit.

1 files changed, 29 insertions, 0 deletions

diff --git a/testapp.c b/testapp.c
index 2bbbc8c..b4ba41a 100644
--- a/testapp.c
+++ b/testapp.c
@@ -244,6 +244,34 @@ static enum test_return cache_redzone_test(void)
 #endif
 }
 
+static enum test_return cache_limit_revised_downward_test(void)
+{
+    int limit = 10, allocated_num = limit + 1, i;
+    char ** alloc_objs = calloc(allocated_num, sizeof(char *));
+
+    cache_t *cache = cache_create("test", sizeof(uint32_t), sizeof(char*),
+                                  NULL, NULL);
+    assert(cache != NULL);
+
+    /* cache->limit is 0 and we can allocate limit+1 items */
+    for (i = 0; i < allocated_num; i++) {
+        alloc_objs[i] = cache_alloc(cache);
+        assert(alloc_objs[i] != NULL);
+    }
+    assert(cache->total == allocated_num);
+
+    /* revised downward cache->limit */
+    cache_set_limit(cache, limit);
+
+    /* If we free one item, the cache->total should decreased by one*/
+    cache_free(cache, alloc_objs[0]);
+
+    assert(cache->total == allocated_num-1);
+    cache_destroy(cache);
+
+    return TEST_PASS;
+}
+
 static enum test_return test_stats_prefix_find(void) {
     PREFIX_STATS *pfs1, *pfs2;
 
@@ -2237,6 +2265,7 @@ struct testcase testcases[] = {
     { "cache_destructor", cache_destructor_test },
     { "cache_reuse", cache_reuse_test },
     { "cache_redzone", cache_redzone_test },
+    { "cache_limit_revised_downward", cache_limit_revised_downward_test },
     { "stats_prefix_find", test_stats_prefix_find },
     { "stats_prefix_record_get", test_stats_prefix_record_get },
     { "stats_prefix_record_delete", test_stats_prefix_record_delete },