X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=smalloc.c;h=ac5754d5f496119a342180eeae58bb4a229e4cf0;hp=7f3c10b137498d01f812e4807298b2f2b06e6870;hb=a639f0bbd278365a2fa15031afd29a24dc917437;hpb=d1271dc19c335c39298e16b825f84fdd8650132e

diff --git a/smalloc.c b/smalloc.c
index 7f3c10b1..ac5754d5 100644
--- a/smalloc.c
+++ b/smalloc.c
@@ -14,7 +14,6 @@
 #include "mutex.h"
 #include "arch/arch.h"
 
-#define MP_SAFE			/* define to make thread safe */
 #define SMALLOC_REDZONE		/* define to detect memory corruption */
 
 #define SMALLOC_BPB	32	/* block size, bytes-per-bit in bitmap */
@@ -28,6 +27,7 @@
 #define SMALLOC_POST_RED	0x5aa55aa5U
 
 unsigned int smalloc_pool_size = INITIAL_SIZE;
+const int int_mask = sizeof(int) - 1;
 
 struct pool {
 	struct fio_mutex *lock;			/* protects this pool */
@@ -37,7 +37,6 @@ struct pool {
 	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;
 };
 
@@ -55,38 +54,32 @@ static struct fio_mutex *lock;
 
 static inline void pool_lock(struct pool *pool)
 {
-	if (pool->lock)
-		fio_mutex_down(pool->lock);
+	fio_mutex_down(pool->lock);
 }
 
 static inline void pool_unlock(struct pool *pool)
 {
-	if (pool->lock)
-		fio_mutex_up(pool->lock);
+	fio_mutex_up(pool->lock);
 }
 
 static inline void global_read_lock(void)
 {
-	if (lock)
-		fio_mutex_down_read(lock);
+	fio_mutex_down_read(lock);
 }
 
 static inline void global_read_unlock(void)
 {
-	if (lock)
-		fio_mutex_up_read(lock);
+	fio_mutex_up_read(lock);
 }
 
 static inline void global_write_lock(void)
 {
-	if (lock)
-		fio_mutex_down_write(lock);
+	fio_mutex_down_write(lock);
 }
 
 static inline void global_write_unlock(void)
 {
-	if (lock)
-		fio_mutex_up_write(lock);
+	fio_mutex_up_write(lock);
 }
 
 static inline int ptr_valid(struct pool *pool, void *ptr)
@@ -183,11 +176,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;
 
@@ -218,12 +211,16 @@ static int add_pool(struct pool *pool, unsigned int alloc_size)
 	pool->map = ptr;
 	pool->bitmap = (void *) ptr + (pool->nr_blocks * SMALLOC_BPL);
 
-#ifdef MP_SAFE
 	pool->lock = fio_mutex_init(1);
 	if (!pool->lock)
 		goto out_unlink;
-#endif
 
+	/*
+	 * 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;
 
 	nr_pools++;
@@ -232,10 +229,9 @@ 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;
 }
 
@@ -243,16 +239,17 @@ void sinit(void)
 {
 	int ret;
 
-#ifdef MP_SAFE
 	lock = fio_mutex_rw_init();
-#endif
 	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);
 
@@ -272,9 +269,19 @@ void scleanup(void)
 }
 
 #ifdef SMALLOC_REDZONE
+static void *postred_ptr(struct block_hdr *hdr)
+{
+	unsigned long ptr;
+
+	ptr = (unsigned long) hdr + hdr->size - sizeof(unsigned int);
+	ptr = (ptr + int_mask) & ~int_mask;
+
+	return (void *) ptr;
+}
+
 static void fill_redzone(struct block_hdr *hdr)
 {
-	unsigned int *postred = (void *) hdr + hdr->size - sizeof(unsigned int);
+	unsigned int *postred = postred_ptr(hdr);
 
 	hdr->prered = SMALLOC_PRE_RED;
 	*postred = SMALLOC_POST_RED;
@@ -282,7 +289,7 @@ static void fill_redzone(struct block_hdr *hdr)
 
 static void sfree_check_redzone(struct block_hdr *hdr)
 {
-	unsigned int *postred = (void *) hdr + hdr->size - sizeof(unsigned int);
+	unsigned int *postred = postred_ptr(hdr);
 
 	if (hdr->prered != SMALLOC_PRE_RED) {
 		fprintf(stderr, "smalloc pre redzone destroyed!\n");
@@ -418,8 +425,13 @@ static void *smalloc_pool(struct pool *pool, unsigned int size)
 	unsigned int alloc_size = size + sizeof(struct block_hdr);
 	void *ptr;
 
+	/*
+	 * Round to int alignment, so that the postred pointer will
+	 * be naturally aligned as well.
+	 */
 #ifdef SMALLOC_REDZONE
 	alloc_size += sizeof(unsigned int);
+	alloc_size = (alloc_size + int_mask) & ~int_mask;
 #endif
 
 	ptr = __smalloc_pool(pool, alloc_size);