smalloc: fix compiler warning on Windows

[fio.git] / smalloc.c

diff --git a/smalloc.c b/smalloc.c
index 7b1690ada90cc9b8b4a106e82648267221995b61..0d7054a429480a51c60d774496191ba7de193850 100644 (file)
--- a/smalloc.c
+++ b/smalloc.c
@@ -5,13 +5,6 @@
 #include <sys/mman.h>
 #include <assert.h>
 #include <string.h>
-#ifdef CONFIG_VALGRIND_DEV
-#include <valgrind/valgrind.h>
-#else
-#define RUNNING_ON_VALGRIND 0
-#define VALGRIND_MALLOCLIKE_BLOCK(addr, size, rzB, is_zeroed) do { } while (0)
-#define VALGRIND_FREELIKE_BLOCK(addr, rzB) do { } while (0)
-#endif
 
 #include "fio.h"
 #include "fio_sem.h"
@@ -48,12 +41,6 @@ struct pool {
        size_t mmap_size;
 };
 
-#ifdef SMALLOC_REDZONE
-#define REDZONE_SIZE sizeof(unsigned int)
-#else
-#define REDZONE_SIZE 0
-#endif
-
 struct block_hdr {
        size_t size;
 #ifdef SMALLOC_REDZONE
@@ -61,6 +48,12 @@ struct block_hdr {
 #endif
 };
 
+/*
+ * This suppresses the voluminous potential bitmap printout when
+ * smalloc encounters an OOM error
+ */
+static const bool enable_smalloc_debug = false;
+
 static struct pool mp[MAX_POOLS];
 static unsigned int nr_pools;
 static unsigned int last_pool;
@@ -263,10 +256,6 @@ static void fill_redzone(struct block_hdr *hdr)
 {
        unsigned int *postred = postred_ptr(hdr);
 
-       /* Let Valgrind fill the red zones. */
-       if (RUNNING_ON_VALGRIND)
-               return;
-
        hdr->prered = SMALLOC_PRE_RED;
        *postred = SMALLOC_POST_RED;
 }
@@ -275,10 +264,6 @@ static void sfree_check_redzone(struct block_hdr *hdr)
 {
        unsigned int *postred = postred_ptr(hdr);
 
-       /* Let Valgrind check the red zones. */
-       if (RUNNING_ON_VALGRIND)
-               return;
-
        if (hdr->prered != SMALLOC_PRE_RED) {
                log_err("smalloc pre redzone destroyed!\n"
                        " ptr=%p, prered=%x, expected %x\n",
@@ -346,7 +331,6 @@ void sfree(void *ptr)
        }
 
        if (pool) {
-               VALGRIND_FREELIKE_BLOCK(ptr, REDZONE_SIZE);
                sfree_pool(pool, ptr);
                return;
        }
@@ -354,6 +338,20 @@ void sfree(void *ptr)
        log_err("smalloc: ptr %p not from smalloc pool\n", ptr);
 }
 
+static unsigned int firstfree(struct pool *pool)
+{
+        unsigned int i;
+
+        for (i = 0; i < pool->nr_blocks; i++)
+                if (pool->bitmap[i] != -1U)
+                        return i;
+
+        assert(0);
+
+       /* we will never get here but this fixes a compiler warning */
+       return -1U;
+}
+
 static void *__smalloc_pool(struct pool *pool, size_t size)
 {
        size_t nr_blocks;
@@ -368,7 +366,14 @@ static void *__smalloc_pool(struct pool *pool, size_t size)
        if (nr_blocks > pool->free_blocks)
                goto fail;
 
-       i = pool->next_non_full;
+       for (i = pool->next_non_full; pool->bitmap[i] == -1U; i++)
+               if (i == pool->nr_blocks - 1) {
+                       i = firstfree(pool);
+                       break;
+               }
+
+       pool->next_non_full = i;
+
        last_idx = 0;
        offset = -1U;
        while (i < pool->nr_blocks) {
@@ -376,7 +381,6 @@ static void *__smalloc_pool(struct pool *pool, size_t size)
 
                if (pool->bitmap[i] == -1U) {
                        i++;
-                       pool->next_non_full = i;
                        last_idx = 0;
                        continue;
                }
@@ -409,10 +413,9 @@ fail:
        return ret;
 }
 
-static void *smalloc_pool(struct pool *pool, size_t size)
+static size_t size_to_alloc_size(size_t size)
 {
        size_t alloc_size = size + sizeof(struct block_hdr);
-       void *ptr;
 
        /*
         * Round to int alignment, so that the postred pointer will
@@ -423,6 +426,14 @@ static void *smalloc_pool(struct pool *pool, size_t size)
        alloc_size = (alloc_size + int_mask) & ~int_mask;
 #endif
 
+       return alloc_size;
+}
+
+static void *smalloc_pool(struct pool *pool, size_t size)
+{
+       size_t alloc_size = size_to_alloc_size(size);
+       void *ptr;
+
        ptr = __smalloc_pool(pool, alloc_size);
        if (ptr) {
                struct block_hdr *hdr = ptr;
@@ -437,7 +448,73 @@ static void *smalloc_pool(struct pool *pool, size_t size)
        return ptr;
 }
 
-static void *__smalloc(size_t size, bool is_zeroed)
+static void smalloc_print_bitmap(struct pool *pool)
+{
+       size_t nr_blocks = pool->nr_blocks;
+       unsigned int *bitmap = pool->bitmap;
+       unsigned int i, j;
+       char *buffer;
+
+       if (!enable_smalloc_debug)
+               return;
+
+       buffer = malloc(SMALLOC_BPI + 1);
+       if (!buffer)
+               return;
+       buffer[SMALLOC_BPI] = '\0';
+
+       for (i = 0; i < nr_blocks; i++) {
+               unsigned int line = bitmap[i];
+
+               /* skip completely full lines */
+               if (line == -1U)
+                       continue;
+
+               for (j = 0; j < SMALLOC_BPI; j++)
+                       if ((1 << j) & line)
+                               buffer[SMALLOC_BPI-1-j] = '1';
+                       else
+                               buffer[SMALLOC_BPI-1-j] = '0';
+
+               log_err("smalloc: bitmap %5u, %s\n", i, buffer);
+       }
+
+       free(buffer);
+}
+
+void smalloc_debug(size_t size)
+{
+       unsigned int i;
+       size_t alloc_size = size_to_alloc_size(size);
+       size_t alloc_blocks;
+
+       alloc_blocks = size_to_blocks(alloc_size);
+
+       if (size)
+               log_err("smalloc: size = %lu, alloc_size = %lu, blocks = %lu\n",
+                       (unsigned long) size, (unsigned long) alloc_size,
+                       (unsigned long) alloc_blocks);
+       for (i = 0; i < nr_pools; i++) {
+               log_err("smalloc: pool %u, free/total blocks %u/%u\n", i,
+                       (unsigned int) (mp[i].free_blocks),
+                       (unsigned int) (mp[i].nr_blocks*sizeof(unsigned int)*8));
+               if (size && mp[i].free_blocks >= alloc_blocks) {
+                       void *ptr = smalloc_pool(&mp[i], size);
+                       if (ptr) {
+                               sfree(ptr);
+                               last_pool = i;
+                               log_err("smalloc: smalloc_pool %u succeeded\n", i);
+                       } else {
+                               log_err("smalloc: smalloc_pool %u failed\n", i);
+                               log_err("smalloc: next_non_full=%u, nr_blocks=%u\n",
+                                       (unsigned int) mp[i].next_non_full, (unsigned int) mp[i].nr_blocks);
+                               smalloc_print_bitmap(&mp[i]);
+                       }
+               }
+       }
+}
+
+void *smalloc(size_t size)
 {
        unsigned int i, end_pool;
 
@@ -453,9 +530,6 @@ static void *__smalloc(size_t size, bool is_zeroed)
 
                        if (ptr) {
                                last_pool = i;
-                               VALGRIND_MALLOCLIKE_BLOCK(ptr, size,
-                                                         REDZONE_SIZE,
-                                                         is_zeroed);
                                return ptr;
                        }
                }
@@ -470,17 +544,13 @@ static void *__smalloc(size_t size, bool is_zeroed)
 
        log_err("smalloc: OOM. Consider using --alloc-size to increase the "
                "shared memory available.\n");
+       smalloc_debug(size);
        return NULL;
 }
 
-void *smalloc(size_t size)
-{
-       return __smalloc(size, false);
-}
-
 void *scalloc(size_t nmemb, size_t size)
 {
-       return __smalloc(nmemb * size, true);
+       return smalloc(nmemb * size);
 }
 
 char *smalloc_strdup(const char *str)