smalloc: only clear the bitmap, not the whole pool

[fio.git] / smalloc.c

diff --git a/smalloc.c b/smalloc.c
index c8f1642eb54cfc7863182286be03d03599dd4dae..5047cda5e3438c8215a3bb549577f5a81e5b0a29 100644 (file)
--- a/smalloc.c
+++ b/smalloc.c
@@ -17,6 +17,7 @@
 #include "arch/arch.h"
 #include "os/os.h"
 #include "smalloc.h"
+#include "log.h"
 
 #define SMALLOC_REDZONE                /* define to detect memory corruption */
 
@@ -24,14 +25,16 @@
 #define SMALLOC_BPI    (sizeof(unsigned int) * 8)
 #define SMALLOC_BPL    (SMALLOC_BPB * SMALLOC_BPI)
 
-#define INITIAL_SIZE   8192*1024       /* new pool size */
-#define MAX_POOLS      128             /* maximum number of pools to setup */
+#define INITIAL_SIZE   16*1024*1024    /* new pool size */
+#define MAX_POOLS      8               /* maximum number of pools to setup */
 
 #define SMALLOC_PRE_RED                0xdeadbeefU
 #define SMALLOC_POST_RED       0x5aa55aa5U
 
 unsigned int smalloc_pool_size = INITIAL_SIZE;
+#ifdef SMALLOC_REDZONE
 static const int int_mask = sizeof(int) - 1;
+#endif
 
 struct pool {
        struct fio_mutex *lock;                 /* protects this pool */
@@ -180,6 +183,7 @@ static int find_next_zero(int word, int start)
 static int add_pool(struct pool *pool, unsigned int alloc_size)
 {
        int bitmap_blocks;
+       int mmap_flags;
        void *ptr;
 
 #ifdef SMALLOC_REDZONE
@@ -198,14 +202,20 @@ static int add_pool(struct pool *pool, unsigned int alloc_size)
        pool->nr_blocks = bitmap_blocks;
        pool->free_blocks = bitmap_blocks * SMALLOC_BPB;
 
-       ptr = mmap(NULL, alloc_size, PROT_READ|PROT_WRITE,
-                       MAP_SHARED | OS_MAP_ANON, -1, 0);
+       mmap_flags = OS_MAP_ANON;
+#ifdef CONFIG_ESX
+       mmap_flags |= MAP_PRIVATE;
+#else
+       mmap_flags |= MAP_SHARED;
+#endif
+       ptr = mmap(NULL, alloc_size, PROT_READ|PROT_WRITE, mmap_flags, -1, 0);
+
        if (ptr == MAP_FAILED)
                goto out_fail;
 
-       memset(ptr, 0, alloc_size);
        pool->map = ptr;
        pool->bitmap = (void *) ptr + (pool->nr_blocks * SMALLOC_BPL);
+       memset(pool->bitmap, 0, bitmap_blocks * sizeof(unsigned int));
 
        pool->lock = fio_mutex_init(FIO_MUTEX_UNLOCKED);
        if (!pool->lock)
@@ -214,7 +224,7 @@ static int add_pool(struct pool *pool, unsigned int alloc_size)
        nr_pools++;
        return 0;
 out_fail:
-       fprintf(stderr, "smalloc: failed adding pool\n");
+       log_err("smalloc: failed adding pool\n");
        if (pool->map)
                munmap(pool->map, pool->mmap_size);
        return 1;
@@ -222,11 +232,21 @@ out_fail:
 
 void sinit(void)
 {
-       int ret;
+       int i, ret;
 
        lock = fio_rwlock_init();
-       ret = add_pool(&mp[0], INITIAL_SIZE);
-       assert(!ret);
+
+       for (i = 0; i < MAX_POOLS; i++) {
+               ret = add_pool(&mp[i], INITIAL_SIZE);
+               if (ret)
+                       break;
+       }
+
+       /*
+        * If we added at least one pool, we should be OK for most
+        * cases.
+        */
+       assert(i);
 }
 
 static void cleanup_pool(struct pool *pool)
@@ -276,14 +296,14 @@ static void sfree_check_redzone(struct block_hdr *hdr)
        unsigned int *postred = postred_ptr(hdr);
 
        if (hdr->prered != SMALLOC_PRE_RED) {
-               fprintf(stderr, "smalloc pre redzone destroyed!\n");
-               fprintf(stderr, "  ptr=%p, prered=%x, expected %x\n",
+               log_err("smalloc pre redzone destroyed!\n"
+                       " ptr=%p, prered=%x, expected %x\n",
                                hdr, hdr->prered, SMALLOC_PRE_RED);
                assert(0);
        }
        if (*postred != SMALLOC_POST_RED) {
-               fprintf(stderr, "smalloc post redzone destroyed!\n");
-               fprintf(stderr, "  ptr=%p, postred=%x, expected %x\n",
+               log_err("smalloc post redzone destroyed!\n"
+                       "  ptr=%p, postred=%x, expected %x\n",
                                hdr, *postred, SMALLOC_POST_RED);
                assert(0);
        }
@@ -345,8 +365,12 @@ void sfree(void *ptr)
 
        global_read_unlock();
 
-       assert(pool);
-       sfree_pool(pool, ptr);
+       if (pool) {
+               sfree_pool(pool, ptr);
+               return;
+       }
+
+       log_err("smalloc: ptr %p not from smalloc pool\n", ptr);
 }
 
 static void *__smalloc_pool(struct pool *pool, size_t size)
@@ -434,16 +458,17 @@ static void *smalloc_pool(struct pool *pool, size_t size)
 
 void *smalloc(size_t size)
 {
-       unsigned int i;
+       unsigned int i, end_pool;
 
        if (size != (unsigned int) size)
                return NULL;
 
        global_write_lock();
        i = last_pool;
+       end_pool = nr_pools;
 
        do {
-               for (; i < nr_pools; i++) {
+               for (; i < end_pool; i++) {
                        void *ptr = smalloc_pool(&mp[i], size);
 
                        if (ptr) {
@@ -453,29 +478,29 @@ void *smalloc(size_t size)
                        }
                }
                if (last_pool) {
-                       last_pool = 0;
+                       end_pool = last_pool;
+                       last_pool = i = 0;
                        continue;
                }
 
-               if (nr_pools + 1 > MAX_POOLS)
-                       break;
-               else {
-                       i = nr_pools;
-                       if (add_pool(&mp[nr_pools], size))
-                               goto out;
-               }
+               break;
        } while (1);
 
-out:
        global_write_unlock();
        return NULL;
 }
 
+void *scalloc(size_t nmemb, size_t size)
+{
+       return smalloc(nmemb * size);
+}
+
 char *smalloc_strdup(const char *str)
 {
-       char *ptr;
+       char *ptr = NULL;
 
        ptr = smalloc(strlen(str) + 1);
-       strcpy(ptr, str);
+       if (ptr)
+               strcpy(ptr, str);
        return ptr;
 }