Cleanup verify headers

[fio.git] / smalloc.c

diff --git a/smalloc.c b/smalloc.c
index 8eb0f2a03740faa63c8e3b0b5681bd6ecaa3ec87..e82ef1da0b59faab23a706db1257808c3fb10bbb 100644 (file)
--- a/smalloc.c
+++ b/smalloc.c
@@ -11,8 +11,8 @@
 #include <sys/types.h>
 #include <limits.h>
 
+#include "mutex.h"
 #include "arch/arch.h"
-#include "spinlock.h"
 
 #define SMALLOC_REDZONE                /* define to detect memory corruption */
 
@@ -21,7 +21,7 @@
 #define SMALLOC_BPL    (SMALLOC_BPB * SMALLOC_BPI)
 
 #define INITIAL_SIZE   1024*1024       /* new pool size */
-#define MAX_POOLS      4               /* maximum number of pools to setup */
+#define MAX_POOLS      128             /* maximum number of pools to setup */
 
 #define SMALLOC_PRE_RED                0xdeadbeefU
 #define SMALLOC_POST_RED       0x5aa55aa5U
@@ -29,14 +29,13 @@
 unsigned int smalloc_pool_size = INITIAL_SIZE;
 
 struct pool {
-       struct fio_spinlock *lock;
+       struct fio_mutex *lock;                 /* protects this pool */
        void *map;                              /* map of blocks */
        unsigned int *bitmap;                   /* blocks free/busy map */
        unsigned int free_blocks;               /* free blocks */
        unsigned int nr_blocks;                 /* total blocks */
        unsigned int next_non_full;
        int fd;                                 /* memory backing fd */
-       char file[PATH_MAX];                    /* filename for fd */
        unsigned int mmap_size;
 };
 
@@ -50,36 +49,36 @@ struct block_hdr {
 static struct pool mp[MAX_POOLS];
 static unsigned int nr_pools;
 static unsigned int last_pool;
-static struct fio_spinlock *slock;
+static struct fio_mutex *lock;
 
 static inline void pool_lock(struct pool *pool)
 {
-       fio_spin_lock(pool->lock);
+       fio_mutex_down(pool->lock);
 }
 
 static inline void pool_unlock(struct pool *pool)
 {
-       fio_spin_unlock(pool->lock);
+       fio_mutex_up(pool->lock);
 }
 
 static inline void global_read_lock(void)
 {
-       fio_spin_lock(slock);
+       fio_mutex_down_read(lock);
 }
 
 static inline void global_read_unlock(void)
 {
-       fio_spin_unlock(slock);
+       fio_mutex_up_read(lock);
 }
 
 static inline void global_write_lock(void)
 {
-       fio_spin_lock(slock);
+       fio_mutex_down_write(lock);
 }
 
 static inline void global_write_unlock(void)
 {
-       fio_spin_unlock(slock);
+       fio_mutex_up_write(lock);
 }
 
 static inline int ptr_valid(struct pool *pool, void *ptr)
@@ -176,11 +175,11 @@ static int find_next_zero(int word, int start)
 
 static int add_pool(struct pool *pool, unsigned int alloc_size)
 {
-       void *ptr;
        int fd, bitmap_blocks;
+       char file[] = "/tmp/.fio_smalloc.XXXXXX";
+       void *ptr;
 
-       strcpy(pool->file, "/tmp/.fio_smalloc.XXXXXX");
-       fd = mkstemp(pool->file);
+       fd = mkstemp(file);
        if (fd < 0)
                goto out_close;
 
@@ -211,24 +210,27 @@ static int add_pool(struct pool *pool, unsigned int alloc_size)
        pool->map = ptr;
        pool->bitmap = (void *) ptr + (pool->nr_blocks * SMALLOC_BPL);
 
-       pool->lock = fio_spinlock_init();
+       pool->lock = fio_mutex_init(1);
        if (!pool->lock)
                goto out_unlink;
 
+       /*
+        * Unlink pool file now. It wont get deleted until the fd is closed,
+        * which happens both for cleanup or unexpected quit. This way we
+        * don't leave temp files around in case of a crash.
+        */
+       unlink(file);
        pool->fd = fd;
 
-       global_write_lock();
        nr_pools++;
-       global_write_unlock();
        return 0;
 out_unlink:
        fprintf(stderr, "smalloc: failed adding pool\n");
        if (pool->map)
                munmap(pool->map, pool->mmap_size);
-       unlink(pool->file);
+       unlink(file);
 out_close:
-       if (fd >= 0)
-               close(fd);
+       close(fd);
        return 1;
 }
 
@@ -236,18 +238,22 @@ void sinit(void)
 {
        int ret;
 
-       slock = fio_spinlock_init();
-       assert(slock);
+       lock = fio_mutex_rw_init();
        ret = add_pool(&mp[0], INITIAL_SIZE);
        assert(!ret);
 }
 
 static void cleanup_pool(struct pool *pool)
 {
-       unlink(pool->file);
+       /*
+        * This will also remove the temporary file we used as a backing
+        * store, it was already unlinked
+        */
        close(pool->fd);
        munmap(pool->map, pool->mmap_size);
-       fio_spinlock_remove(pool->lock);
+
+       if (pool->lock)
+               fio_mutex_remove(pool->lock);
 }
 
 void scleanup(void)
@@ -257,7 +263,8 @@ void scleanup(void)
        for (i = 0; i < nr_pools; i++)
                cleanup_pool(&mp[i]);
 
-       fio_spinlock_remove(slock);
+       if (lock)
+               fio_mutex_remove(lock);
 }
 
 #ifdef SMALLOC_REDZONE
@@ -429,7 +436,7 @@ void *smalloc(unsigned int size)
 {
        unsigned int i;
 
-       global_read_lock();
+       global_write_lock();
        i = last_pool;
 
        do {
@@ -438,7 +445,7 @@ void *smalloc(unsigned int size)
 
                        if (ptr) {
                                last_pool = i;
-                               global_read_unlock();
+                               global_write_unlock();
                                return ptr;
                        }
                }
@@ -451,15 +458,13 @@ void *smalloc(unsigned int size)
                        break;
                else {
                        i = nr_pools;
-                       global_read_unlock();
                        if (add_pool(&mp[nr_pools], size))
                                goto out;
-                       global_read_lock();
                }
        } while (1);
 
-       global_read_unlock();
 out:
+       global_write_unlock();
        return NULL;
 }