summaryrefslogtreecommitdiffstats
path: root/libglusterfs/src/mem-pool.c
diff options
context:
space:
mode:
Diffstat (limited to 'libglusterfs/src/mem-pool.c')
-rw-r--r--libglusterfs/src/mem-pool.c1354
1 files changed, 676 insertions, 678 deletions
diff --git a/libglusterfs/src/mem-pool.c b/libglusterfs/src/mem-pool.c
index 4b140296b4f..cff96323867 100644
--- a/libglusterfs/src/mem-pool.c
+++ b/libglusterfs/src/mem-pool.c
@@ -18,528 +18,519 @@
#include "libglusterfs-messages.h"
void
-gf_mem_acct_enable_set (void *data)
+gf_mem_acct_enable_set(void *data)
{
- glusterfs_ctx_t *ctx = NULL;
+ glusterfs_ctx_t *ctx = NULL;
- REQUIRE(data != NULL);
+ REQUIRE(data != NULL);
- ctx = data;
+ ctx = data;
- GF_ASSERT (ctx != NULL);
+ GF_ASSERT(ctx != NULL);
- ctx->mem_acct_enable = 1;
+ ctx->mem_acct_enable = 1;
- ENSURE(1 == ctx->mem_acct_enable);
+ ENSURE(1 == ctx->mem_acct_enable);
- return;
+ return;
}
int
-gf_mem_set_acct_info (xlator_t *xl, char **alloc_ptr, size_t size,
- uint32_t type, const char *typestr)
+gf_mem_set_acct_info(xlator_t *xl, char **alloc_ptr, size_t size, uint32_t type,
+ const char *typestr)
{
+ void *ptr = NULL;
+ struct mem_header *header = NULL;
- void *ptr = NULL;
- struct mem_header *header = NULL;
+ if (!alloc_ptr)
+ return -1;
- if (!alloc_ptr)
- return -1;
+ ptr = *alloc_ptr;
- ptr = *alloc_ptr;
+ GF_ASSERT(xl != NULL);
- GF_ASSERT (xl != NULL);
+ GF_ASSERT(xl->mem_acct != NULL);
- GF_ASSERT (xl->mem_acct != NULL);
+ GF_ASSERT(type <= xl->mem_acct->num_types);
- GF_ASSERT (type <= xl->mem_acct->num_types);
+ LOCK(&xl->mem_acct->rec[type].lock);
+ {
+ if (!xl->mem_acct->rec[type].typestr)
+ xl->mem_acct->rec[type].typestr = typestr;
+ xl->mem_acct->rec[type].size += size;
+ xl->mem_acct->rec[type].num_allocs++;
+ xl->mem_acct->rec[type].total_allocs++;
+ xl->mem_acct->rec[type].max_size = max(xl->mem_acct->rec[type].max_size,
+ xl->mem_acct->rec[type].size);
+ xl->mem_acct->rec[type].max_num_allocs = max(
+ xl->mem_acct->rec[type].max_num_allocs,
+ xl->mem_acct->rec[type].num_allocs);
+ }
+ UNLOCK(&xl->mem_acct->rec[type].lock);
- LOCK(&xl->mem_acct->rec[type].lock);
- {
- if (!xl->mem_acct->rec[type].typestr)
- xl->mem_acct->rec[type].typestr = typestr;
- xl->mem_acct->rec[type].size += size;
- xl->mem_acct->rec[type].num_allocs++;
- xl->mem_acct->rec[type].total_allocs++;
- xl->mem_acct->rec[type].max_size =
- max (xl->mem_acct->rec[type].max_size,
- xl->mem_acct->rec[type].size);
- xl->mem_acct->rec[type].max_num_allocs =
- max (xl->mem_acct->rec[type].max_num_allocs,
- xl->mem_acct->rec[type].num_allocs);
- }
- UNLOCK(&xl->mem_acct->rec[type].lock);
+ GF_ATOMIC_INC(xl->mem_acct->refcnt);
- GF_ATOMIC_INC (xl->mem_acct->refcnt);
-
- header = (struct mem_header *) ptr;
- header->type = type;
- header->size = size;
- header->mem_acct = xl->mem_acct;
- header->magic = GF_MEM_HEADER_MAGIC;
+ header = (struct mem_header *)ptr;
+ header->type = type;
+ header->size = size;
+ header->mem_acct = xl->mem_acct;
+ header->magic = GF_MEM_HEADER_MAGIC;
#ifdef DEBUG
- INIT_LIST_HEAD(&header->acct_list);
- LOCK(&xl->mem_acct->rec[type].lock);
- {
- list_add (&header->acct_list,
- &(xl->mem_acct->rec[type].obj_list));
- }
- UNLOCK(&xl->mem_acct->rec[type].lock);
+ INIT_LIST_HEAD(&header->acct_list);
+ LOCK(&xl->mem_acct->rec[type].lock);
+ {
+ list_add(&header->acct_list, &(xl->mem_acct->rec[type].obj_list));
+ }
+ UNLOCK(&xl->mem_acct->rec[type].lock);
#endif
- ptr += sizeof (struct mem_header);
- /* data follows in this gap of 'size' bytes */
- *(uint32_t *) (ptr + size) = GF_MEM_TRAILER_MAGIC;
+ ptr += sizeof(struct mem_header);
+ /* data follows in this gap of 'size' bytes */
+ *(uint32_t *)(ptr + size) = GF_MEM_TRAILER_MAGIC;
- *alloc_ptr = ptr;
- return 0;
+ *alloc_ptr = ptr;
+ return 0;
}
-
void *
-__gf_calloc (size_t nmemb, size_t size, uint32_t type, const char *typestr)
+__gf_calloc(size_t nmemb, size_t size, uint32_t type, const char *typestr)
{
- size_t tot_size = 0;
- size_t req_size = 0;
- char *ptr = NULL;
- xlator_t *xl = NULL;
+ size_t tot_size = 0;
+ size_t req_size = 0;
+ char *ptr = NULL;
+ xlator_t *xl = NULL;
- if (!THIS->ctx->mem_acct_enable)
- return CALLOC (nmemb, size);
+ if (!THIS->ctx->mem_acct_enable)
+ return CALLOC(nmemb, size);
- xl = THIS;
+ xl = THIS;
- req_size = nmemb * size;
- tot_size = req_size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
+ req_size = nmemb * size;
+ tot_size = req_size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
- ptr = calloc (1, tot_size);
+ ptr = calloc(1, tot_size);
- if (!ptr) {
- gf_msg_nomem ("", GF_LOG_ALERT, tot_size);
- return NULL;
- }
- gf_mem_set_acct_info (xl, &ptr, req_size, type, typestr);
+ if (!ptr) {
+ gf_msg_nomem("", GF_LOG_ALERT, tot_size);
+ return NULL;
+ }
+ gf_mem_set_acct_info(xl, &ptr, req_size, type, typestr);
- return (void *)ptr;
+ return (void *)ptr;
}
void *
-__gf_malloc (size_t size, uint32_t type, const char *typestr)
+__gf_malloc(size_t size, uint32_t type, const char *typestr)
{
- size_t tot_size = 0;
- char *ptr = NULL;
- xlator_t *xl = NULL;
+ size_t tot_size = 0;
+ char *ptr = NULL;
+ xlator_t *xl = NULL;
- if (!THIS->ctx->mem_acct_enable)
- return MALLOC (size);
+ if (!THIS->ctx->mem_acct_enable)
+ return MALLOC(size);
- xl = THIS;
+ xl = THIS;
- tot_size = size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
+ tot_size = size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
- ptr = malloc (tot_size);
- if (!ptr) {
- gf_msg_nomem ("", GF_LOG_ALERT, tot_size);
- return NULL;
- }
- gf_mem_set_acct_info (xl, &ptr, size, type, typestr);
+ ptr = malloc(tot_size);
+ if (!ptr) {
+ gf_msg_nomem("", GF_LOG_ALERT, tot_size);
+ return NULL;
+ }
+ gf_mem_set_acct_info(xl, &ptr, size, type, typestr);
- return (void *)ptr;
+ return (void *)ptr;
}
void *
-__gf_realloc (void *ptr, size_t size)
+__gf_realloc(void *ptr, size_t size)
{
- size_t tot_size = 0;
- char *new_ptr;
- struct mem_header *old_header = NULL;
- struct mem_header *new_header = NULL;
- struct mem_header tmp_header;
+ size_t tot_size = 0;
+ char *new_ptr;
+ struct mem_header *old_header = NULL;
+ struct mem_header *new_header = NULL;
+ struct mem_header tmp_header;
- if (!THIS->ctx->mem_acct_enable)
- return REALLOC (ptr, size);
+ if (!THIS->ctx->mem_acct_enable)
+ return REALLOC(ptr, size);
- REQUIRE(NULL != ptr);
+ REQUIRE(NULL != ptr);
- old_header = (struct mem_header *) (ptr - GF_MEM_HEADER_SIZE);
- GF_ASSERT (old_header->magic == GF_MEM_HEADER_MAGIC);
- tmp_header = *old_header;
+ old_header = (struct mem_header *)(ptr - GF_MEM_HEADER_SIZE);
+ GF_ASSERT(old_header->magic == GF_MEM_HEADER_MAGIC);
+ tmp_header = *old_header;
#ifdef DEBUG
- int type = 0;
- size_t copy_size = 0;
-
- /* Making these changes for realloc is not straightforward. So
- * I am simulating realloc using calloc and free
- */
-
- type = tmp_header.type;
- new_ptr = __gf_calloc (1, size, type,
- tmp_header.mem_acct->rec[type].typestr);
- if (new_ptr) {
- copy_size = (size > tmp_header.size) ? tmp_header.size : size;
- memcpy (new_ptr, ptr, copy_size);
- __gf_free (ptr);
- }
-
- /* This is not quite what the man page says should happen */
- return new_ptr;
+ int type = 0;
+ size_t copy_size = 0;
+
+ /* Making these changes for realloc is not straightforward. So
+ * I am simulating realloc using calloc and free
+ */
+
+ type = tmp_header.type;
+ new_ptr = __gf_calloc(1, size, type,
+ tmp_header.mem_acct->rec[type].typestr);
+ if (new_ptr) {
+ copy_size = (size > tmp_header.size) ? tmp_header.size : size;
+ memcpy(new_ptr, ptr, copy_size);
+ __gf_free(ptr);
+ }
+
+ /* This is not quite what the man page says should happen */
+ return new_ptr;
#endif
- tot_size = size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
- new_ptr = realloc (old_header, tot_size);
- if (!new_ptr) {
- gf_msg_nomem ("", GF_LOG_ALERT, tot_size);
- return NULL;
- }
-
- /*
- * We used to pass (char **)&ptr as the second
- * argument after the value of realloc was saved
- * in ptr, but the compiler warnings complained
- * about the casting to and forth from void ** to
- * char **.
- * TBD: it would be nice to adjust the memory accounting info here,
- * but calling gf_mem_set_acct_info here is wrong because it bumps
- * up counts as though this is a new allocation - which it's not.
- * The consequence of doing nothing here is only that the sizes will be
- * wrong, but at least the counts won't be.
- uint32_t type = 0;
- xlator_t *xl = NULL;
- type = header->type;
- xl = (xlator_t *) header->xlator;
- gf_mem_set_acct_info (xl, &new_ptr, size, type, NULL);
- */
-
- new_header = (struct mem_header *) new_ptr;
- *new_header = tmp_header;
- new_header->size = size;
-
- new_ptr += sizeof (struct mem_header);
- /* data follows in this gap of 'size' bytes */
- *(uint32_t *) (new_ptr + size) = GF_MEM_TRAILER_MAGIC;
-
- return (void *)new_ptr;
+ tot_size = size + GF_MEM_HEADER_SIZE + GF_MEM_TRAILER_SIZE;
+ new_ptr = realloc(old_header, tot_size);
+ if (!new_ptr) {
+ gf_msg_nomem("", GF_LOG_ALERT, tot_size);
+ return NULL;
+ }
+
+ /*
+ * We used to pass (char **)&ptr as the second
+ * argument after the value of realloc was saved
+ * in ptr, but the compiler warnings complained
+ * about the casting to and forth from void ** to
+ * char **.
+ * TBD: it would be nice to adjust the memory accounting info here,
+ * but calling gf_mem_set_acct_info here is wrong because it bumps
+ * up counts as though this is a new allocation - which it's not.
+ * The consequence of doing nothing here is only that the sizes will be
+ * wrong, but at least the counts won't be.
+ uint32_t type = 0;
+ xlator_t *xl = NULL;
+ type = header->type;
+ xl = (xlator_t *) header->xlator;
+ gf_mem_set_acct_info (xl, &new_ptr, size, type, NULL);
+ */
+
+ new_header = (struct mem_header *)new_ptr;
+ *new_header = tmp_header;
+ new_header->size = size;
+
+ new_ptr += sizeof(struct mem_header);
+ /* data follows in this gap of 'size' bytes */
+ *(uint32_t *)(new_ptr + size) = GF_MEM_TRAILER_MAGIC;
+
+ return (void *)new_ptr;
}
int
-gf_vasprintf (char **string_ptr, const char *format, va_list arg)
+gf_vasprintf(char **string_ptr, const char *format, va_list arg)
{
- va_list arg_save;
- char *str = NULL;
- int size = 0;
- int rv = 0;
-
- if (!string_ptr || !format)
- return -1;
-
- va_copy (arg_save, arg);
-
- size = vsnprintf (NULL, 0, format, arg);
- size++;
- str = GF_MALLOC (size, gf_common_mt_asprintf);
- if (str == NULL) {
- /* log is done in GF_MALLOC itself */
- va_end (arg_save);
- return -1;
- }
- rv = vsnprintf (str, size, format, arg_save);
-
- *string_ptr = str;
- va_end (arg_save);
- return (rv);
+ va_list arg_save;
+ char *str = NULL;
+ int size = 0;
+ int rv = 0;
+
+ if (!string_ptr || !format)
+ return -1;
+
+ va_copy(arg_save, arg);
+
+ size = vsnprintf(NULL, 0, format, arg);
+ size++;
+ str = GF_MALLOC(size, gf_common_mt_asprintf);
+ if (str == NULL) {
+ /* log is done in GF_MALLOC itself */
+ va_end(arg_save);
+ return -1;
+ }
+ rv = vsnprintf(str, size, format, arg_save);
+
+ *string_ptr = str;
+ va_end(arg_save);
+ return (rv);
}
int
-gf_asprintf (char **string_ptr, const char *format, ...)
+gf_asprintf(char **string_ptr, const char *format, ...)
{
- va_list arg;
- int rv = 0;
+ va_list arg;
+ int rv = 0;
- va_start (arg, format);
- rv = gf_vasprintf (string_ptr, format, arg);
- va_end (arg);
+ va_start(arg, format);
+ rv = gf_vasprintf(string_ptr, format, arg);
+ va_end(arg);
- return rv;
+ return rv;
}
#ifdef DEBUG
void
-__gf_mem_invalidate (void *ptr)
+__gf_mem_invalidate(void *ptr)
{
- struct mem_header *header = ptr;
- void *end = NULL;
-
- struct mem_invalid inval = {
- .magic = GF_MEM_INVALID_MAGIC,
- .mem_acct = header->mem_acct,
- .type = header->type,
- .size = header->size,
- .baseaddr = ptr + GF_MEM_HEADER_SIZE,
- };
-
- /* calculate the last byte of the allocated area */
- end = ptr + GF_MEM_HEADER_SIZE + inval.size + GF_MEM_TRAILER_SIZE;
-
- /* overwrite the old mem_header */
- memcpy (ptr, &inval, sizeof (inval));
- ptr += sizeof (inval);
-
- /* zero out remaining (old) mem_header bytes) */
- memset (ptr, 0x00, sizeof (*header) - sizeof (inval));
- ptr += sizeof (*header) - sizeof (inval);
-
- /* zero out the first byte of data */
- *(uint32_t *)(ptr) = 0x00;
- ptr += 1;
-
- /* repeated writes of invalid structurein data area */
- while ((ptr + (sizeof (inval))) < (end - 1)) {
- memcpy (ptr, &inval, sizeof (inval));
- ptr += sizeof (inval);
- }
-
- /* fill out remaining data area with 0xff */
- memset (ptr, 0xff, end - ptr);
+ struct mem_header *header = ptr;
+ void *end = NULL;
+
+ struct mem_invalid inval = {
+ .magic = GF_MEM_INVALID_MAGIC,
+ .mem_acct = header->mem_acct,
+ .type = header->type,
+ .size = header->size,
+ .baseaddr = ptr + GF_MEM_HEADER_SIZE,
+ };
+
+ /* calculate the last byte of the allocated area */
+ end = ptr + GF_MEM_HEADER_SIZE + inval.size + GF_MEM_TRAILER_SIZE;
+
+ /* overwrite the old mem_header */
+ memcpy(ptr, &inval, sizeof(inval));
+ ptr += sizeof(inval);
+
+ /* zero out remaining (old) mem_header bytes) */
+ memset(ptr, 0x00, sizeof(*header) - sizeof(inval));
+ ptr += sizeof(*header) - sizeof(inval);
+
+ /* zero out the first byte of data */
+ *(uint32_t *)(ptr) = 0x00;
+ ptr += 1;
+
+ /* repeated writes of invalid structurein data area */
+ while ((ptr + (sizeof(inval))) < (end - 1)) {
+ memcpy(ptr, &inval, sizeof(inval));
+ ptr += sizeof(inval);
+ }
+
+ /* fill out remaining data area with 0xff */
+ memset(ptr, 0xff, end - ptr);
}
#endif /* DEBUG */
void
-__gf_free (void *free_ptr)
+__gf_free(void *free_ptr)
{
- void *ptr = NULL;
- struct mem_acct *mem_acct;
- struct mem_header *header = NULL;
+ void *ptr = NULL;
+ struct mem_acct *mem_acct;
+ struct mem_header *header = NULL;
- if (!THIS->ctx->mem_acct_enable) {
- FREE (free_ptr);
- return;
- }
-
- if (!free_ptr)
- return;
-
- ptr = free_ptr - GF_MEM_HEADER_SIZE;
- header = (struct mem_header *) ptr;
-
- //Possible corruption, assert here
- GF_ASSERT (GF_MEM_HEADER_MAGIC == header->magic);
-
- mem_acct = header->mem_acct;
- if (!mem_acct) {
- goto free;
- }
+ if (!THIS->ctx->mem_acct_enable) {
+ FREE(free_ptr);
+ return;
+ }
- // This points to a memory overrun
- GF_ASSERT (GF_MEM_TRAILER_MAGIC ==
- *(uint32_t *)((char *)free_ptr + header->size));
+ if (!free_ptr)
+ return;
- LOCK (&mem_acct->rec[header->type].lock);
- {
- mem_acct->rec[header->type].size -= header->size;
- mem_acct->rec[header->type].num_allocs--;
- /* If all the instances are freed up then ensure typestr is set
- * to NULL */
- if (!mem_acct->rec[header->type].num_allocs)
- mem_acct->rec[header->type].typestr = NULL;
+ ptr = free_ptr - GF_MEM_HEADER_SIZE;
+ header = (struct mem_header *)ptr;
+
+ // Possible corruption, assert here
+ GF_ASSERT(GF_MEM_HEADER_MAGIC == header->magic);
+
+ mem_acct = header->mem_acct;
+ if (!mem_acct) {
+ goto free;
+ }
+
+ // This points to a memory overrun
+ GF_ASSERT(GF_MEM_TRAILER_MAGIC ==
+ *(uint32_t *)((char *)free_ptr + header->size));
+
+ LOCK(&mem_acct->rec[header->type].lock);
+ {
+ mem_acct->rec[header->type].size -= header->size;
+ mem_acct->rec[header->type].num_allocs--;
+ /* If all the instances are freed up then ensure typestr is set
+ * to NULL */
+ if (!mem_acct->rec[header->type].num_allocs)
+ mem_acct->rec[header->type].typestr = NULL;
#ifdef DEBUG
- list_del (&header->acct_list);
+ list_del(&header->acct_list);
#endif
- }
- UNLOCK (&mem_acct->rec[header->type].lock);
+ }
+ UNLOCK(&mem_acct->rec[header->type].lock);
- if (GF_ATOMIC_DEC (mem_acct->refcnt) == 0) {
- FREE (mem_acct);
- }
+ if (GF_ATOMIC_DEC(mem_acct->refcnt) == 0) {
+ FREE(mem_acct);
+ }
free:
#ifdef DEBUG
- __gf_mem_invalidate (ptr);
+ __gf_mem_invalidate(ptr);
#endif
- FREE (ptr);
+ FREE(ptr);
}
-#define POOL_SMALLEST 7 /* i.e. 128 */
-#define POOL_LARGEST 20 /* i.e. 1048576 */
-#define NPOOLS (POOL_LARGEST - POOL_SMALLEST + 1)
+#define POOL_SMALLEST 7 /* i.e. 128 */
+#define POOL_LARGEST 20 /* i.e. 1048576 */
+#define NPOOLS (POOL_LARGEST - POOL_SMALLEST + 1)
-static pthread_key_t pool_key;
-static pthread_mutex_t pool_lock = PTHREAD_MUTEX_INITIALIZER;
-static struct list_head pool_threads;
-static pthread_mutex_t pool_free_lock = PTHREAD_MUTEX_INITIALIZER;
-static struct list_head pool_free_threads;
-static struct mem_pool_shared pools[NPOOLS];
-static size_t pool_list_size;
+static pthread_key_t pool_key;
+static pthread_mutex_t pool_lock = PTHREAD_MUTEX_INITIALIZER;
+static struct list_head pool_threads;
+static pthread_mutex_t pool_free_lock = PTHREAD_MUTEX_INITIALIZER;
+static struct list_head pool_free_threads;
+static struct mem_pool_shared pools[NPOOLS];
+static size_t pool_list_size;
#if !defined(GF_DISABLE_MEMPOOL)
-#define N_COLD_LISTS 1024
+#define N_COLD_LISTS 1024
#define POOL_SWEEP_SECS 30
-static unsigned long sweep_times;
-static unsigned long sweep_usecs;
-static unsigned long frees_to_system;
+static unsigned long sweep_times;
+static unsigned long sweep_usecs;
+static unsigned long frees_to_system;
typedef struct {
- struct list_head death_row;
- pooled_obj_hdr_t *cold_lists[N_COLD_LISTS];
- unsigned int n_cold_lists;
+ struct list_head death_row;
+ pooled_obj_hdr_t *cold_lists[N_COLD_LISTS];
+ unsigned int n_cold_lists;
} sweep_state_t;
enum init_state {
- GF_MEMPOOL_INIT_NONE = 0,
- GF_MEMPOOL_INIT_PREINIT,
- GF_MEMPOOL_INIT_EARLY,
- GF_MEMPOOL_INIT_LATE,
- GF_MEMPOOL_INIT_DESTROY
+ GF_MEMPOOL_INIT_NONE = 0,
+ GF_MEMPOOL_INIT_PREINIT,
+ GF_MEMPOOL_INIT_EARLY,
+ GF_MEMPOOL_INIT_LATE,
+ GF_MEMPOOL_INIT_DESTROY
};
-static enum init_state init_done = GF_MEMPOOL_INIT_NONE;
-static pthread_mutex_t init_mutex = PTHREAD_MUTEX_INITIALIZER;
-static unsigned int init_count = 0;
-static pthread_t sweeper_tid;
-
+static enum init_state init_done = GF_MEMPOOL_INIT_NONE;
+static pthread_mutex_t init_mutex = PTHREAD_MUTEX_INITIALIZER;
+static unsigned int init_count = 0;
+static pthread_t sweeper_tid;
void
-collect_garbage (sweep_state_t *state, per_thread_pool_list_t *pool_list)
+collect_garbage(sweep_state_t *state, per_thread_pool_list_t *pool_list)
{
- unsigned int i;
- per_thread_pool_t *pt_pool;
+ unsigned int i;
+ per_thread_pool_t *pt_pool;
- if (pool_list->poison) {
- list_del (&pool_list->thr_list);
- list_add (&pool_list->thr_list, &state->death_row);
- return;
- }
+ if (pool_list->poison) {
+ list_del(&pool_list->thr_list);
+ list_add(&pool_list->thr_list, &state->death_row);
+ return;
+ }
- if (state->n_cold_lists >= N_COLD_LISTS) {
- return;
- }
+ if (state->n_cold_lists >= N_COLD_LISTS) {
+ return;
+ }
- (void) pthread_spin_lock (&pool_list->lock);
- for (i = 0; i < NPOOLS; ++i) {
- pt_pool = &pool_list->pools[i];
- if (pt_pool->cold_list) {
- state->cold_lists[state->n_cold_lists++]
- = pt_pool->cold_list;
- }
- pt_pool->cold_list = pt_pool->hot_list;
- pt_pool->hot_list = NULL;
- if (state->n_cold_lists >= N_COLD_LISTS) {
- /* We'll just catch up on a future pass. */
- break;
- }
+ (void)pthread_spin_lock(&pool_list->lock);
+ for (i = 0; i < NPOOLS; ++i) {
+ pt_pool = &pool_list->pools[i];
+ if (pt_pool->cold_list) {
+ state->cold_lists[state->n_cold_lists++] = pt_pool->cold_list;
+ }
+ pt_pool->cold_list = pt_pool->hot_list;
+ pt_pool->hot_list = NULL;
+ if (state->n_cold_lists >= N_COLD_LISTS) {
+ /* We'll just catch up on a future pass. */
+ break;
}
- (void) pthread_spin_unlock (&pool_list->lock);
+ }
+ (void)pthread_spin_unlock(&pool_list->lock);
}
-
void
-free_obj_list (pooled_obj_hdr_t *victim)
+free_obj_list(pooled_obj_hdr_t *victim)
{
- pooled_obj_hdr_t *next;
-
- while (victim) {
- next = victim->next;
- free (victim);
- victim = next;
- ++frees_to_system;
- }
+ pooled_obj_hdr_t *next;
+
+ while (victim) {
+ next = victim->next;
+ free(victim);
+ victim = next;
+ ++frees_to_system;
+ }
}
void *
-pool_sweeper (void *arg)
+pool_sweeper(void *arg)
{
- sweep_state_t state;
- per_thread_pool_list_t *pool_list;
- per_thread_pool_list_t *next_pl;
- per_thread_pool_t *pt_pool;
- unsigned int i;
- struct timeval begin_time;
- struct timeval end_time;
- struct timeval elapsed;
-
- /*
- * This is all a bit inelegant, but the point is to avoid doing
- * expensive things (like freeing thousands of objects) while holding a
- * global lock. Thus, we split each iteration into three passes, with
- * only the first and fastest holding the lock.
- */
-
- for (;;) {
- sleep (POOL_SWEEP_SECS);
- (void) pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, NULL);
- INIT_LIST_HEAD (&state.death_row);
- state.n_cold_lists = 0;
-
- /* First pass: collect stuff that needs our attention. */
- (void) gettimeofday (&begin_time, NULL);
- (void) pthread_mutex_lock (&pool_lock);
- list_for_each_entry_safe (pool_list, next_pl,
- &pool_threads, thr_list) {
- collect_garbage (&state, pool_list);
- }
- (void) pthread_mutex_unlock (&pool_lock);
- (void) gettimeofday (&end_time, NULL);
- timersub (&end_time, &begin_time, &elapsed);
- sweep_usecs += elapsed.tv_sec * 1000000 + elapsed.tv_usec;
- sweep_times += 1;
-
- /* Second pass: free dead pools. */
- (void) pthread_mutex_lock (&pool_free_lock);
- list_for_each_entry_safe (pool_list, next_pl,
- &state.death_row, thr_list) {
- for (i = 0; i < NPOOLS; ++i) {
- pt_pool = &pool_list->pools[i];
- free_obj_list (pt_pool->cold_list);
- free_obj_list (pt_pool->hot_list);
- pt_pool->hot_list = pt_pool->cold_list = NULL;
- }
- list_del (&pool_list->thr_list);
- list_add (&pool_list->thr_list, &pool_free_threads);
- }
- (void) pthread_mutex_unlock (&pool_free_lock);
+ sweep_state_t state;
+ per_thread_pool_list_t *pool_list;
+ per_thread_pool_list_t *next_pl;
+ per_thread_pool_t *pt_pool;
+ unsigned int i;
+ struct timeval begin_time;
+ struct timeval end_time;
+ struct timeval elapsed;
+
+ /*
+ * This is all a bit inelegant, but the point is to avoid doing
+ * expensive things (like freeing thousands of objects) while holding a
+ * global lock. Thus, we split each iteration into three passes, with
+ * only the first and fastest holding the lock.
+ */
+
+ for (;;) {
+ sleep(POOL_SWEEP_SECS);
+ (void)pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
+ INIT_LIST_HEAD(&state.death_row);
+ state.n_cold_lists = 0;
+
+ /* First pass: collect stuff that needs our attention. */
+ (void)gettimeofday(&begin_time, NULL);
+ (void)pthread_mutex_lock(&pool_lock);
+ list_for_each_entry_safe(pool_list, next_pl, &pool_threads, thr_list)
+ {
+ collect_garbage(&state, pool_list);
+ }
+ (void)pthread_mutex_unlock(&pool_lock);
+ (void)gettimeofday(&end_time, NULL);
+ timersub(&end_time, &begin_time, &elapsed);
+ sweep_usecs += elapsed.tv_sec * 1000000 + elapsed.tv_usec;
+ sweep_times += 1;
- /* Third pass: free cold objects from live pools. */
- for (i = 0; i < state.n_cold_lists; ++i) {
- free_obj_list (state.cold_lists[i]);
- }
- (void) pthread_setcancelstate (PTHREAD_CANCEL_ENABLE, NULL);
+ /* Second pass: free dead pools. */
+ (void)pthread_mutex_lock(&pool_free_lock);
+ list_for_each_entry_safe(pool_list, next_pl, &state.death_row, thr_list)
+ {
+ for (i = 0; i < NPOOLS; ++i) {
+ pt_pool = &pool_list->pools[i];
+ free_obj_list(pt_pool->cold_list);
+ free_obj_list(pt_pool->hot_list);
+ pt_pool->hot_list = pt_pool->cold_list = NULL;
+ }
+ list_del(&pool_list->thr_list);
+ list_add(&pool_list->thr_list, &pool_free_threads);
}
-}
+ (void)pthread_mutex_unlock(&pool_free_lock);
+ /* Third pass: free cold objects from live pools. */
+ for (i = 0; i < state.n_cold_lists; ++i) {
+ free_obj_list(state.cold_lists[i]);
+ }
+ (void)pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+ }
+}
void
-pool_destructor (void *arg)
+pool_destructor(void *arg)
{
- per_thread_pool_list_t *pool_list = arg;
+ per_thread_pool_list_t *pool_list = arg;
- /* The pool-sweeper thread will take it from here. */
- pool_list->poison = 1;
+ /* The pool-sweeper thread will take it from here. */
+ pool_list->poison = 1;
}
-
static __attribute__((constructor)) void
-mem_pools_preinit (void)
+mem_pools_preinit(void)
{
- unsigned int i;
+ unsigned int i;
- INIT_LIST_HEAD (&pool_threads);
- INIT_LIST_HEAD (&pool_free_threads);
+ INIT_LIST_HEAD(&pool_threads);
+ INIT_LIST_HEAD(&pool_free_threads);
- for (i = 0; i < NPOOLS; ++i) {
- pools[i].power_of_two = POOL_SMALLEST + i;
+ for (i = 0; i < NPOOLS; ++i) {
+ pools[i].power_of_two = POOL_SMALLEST + i;
- GF_ATOMIC_INIT (pools[i].allocs_hot, 0);
- GF_ATOMIC_INIT (pools[i].allocs_cold, 0);
- GF_ATOMIC_INIT (pools[i].allocs_stdc, 0);
- GF_ATOMIC_INIT (pools[i].frees_to_list, 0);
- }
+ GF_ATOMIC_INIT(pools[i].allocs_hot, 0);
+ GF_ATOMIC_INIT(pools[i].allocs_cold, 0);
+ GF_ATOMIC_INIT(pools[i].allocs_stdc, 0);
+ GF_ATOMIC_INIT(pools[i].frees_to_list, 0);
+ }
- pool_list_size = sizeof (per_thread_pool_list_t)
- + sizeof (per_thread_pool_t) * (NPOOLS - 1);
+ pool_list_size = sizeof(per_thread_pool_list_t) +
+ sizeof(per_thread_pool_t) * (NPOOLS - 1);
- init_done = GF_MEMPOOL_INIT_PREINIT;
+ init_done = GF_MEMPOOL_INIT_PREINIT;
}
/* Use mem_pools_init_early() function for basic initialization. There will be
@@ -547,358 +538,365 @@ mem_pools_preinit (void)
* been called. Calling mem_get() will be possible after this function has
* setup the basic structures. */
void
-mem_pools_init_early (void)
+mem_pools_init_early(void)
{
- pthread_mutex_lock (&init_mutex);
- /* Use a pthread_key destructor to clean up when a thread exits.
- *
- * We won't increase init_count here, that is only done when the
- * pool_sweeper thread is started too.
- */
- if (init_done == GF_MEMPOOL_INIT_PREINIT ||
- init_done == GF_MEMPOOL_INIT_DESTROY) {
- /* key has not been created yet */
- if (pthread_key_create (&pool_key, pool_destructor) != 0) {
- gf_log ("mem-pool", GF_LOG_CRITICAL,
- "failed to initialize mem-pool key");
- }
-
- init_done = GF_MEMPOOL_INIT_EARLY;
- } else {
- gf_log ("mem-pool", GF_LOG_CRITICAL,
- "incorrect order of mem-pool initialization "
- "(init_done=%d)", init_done);
- }
-
- pthread_mutex_unlock (&init_mutex);
+ pthread_mutex_lock(&init_mutex);
+ /* Use a pthread_key destructor to clean up when a thread exits.
+ *
+ * We won't increase init_count here, that is only done when the
+ * pool_sweeper thread is started too.
+ */
+ if (init_done == GF_MEMPOOL_INIT_PREINIT ||
+ init_done == GF_MEMPOOL_INIT_DESTROY) {
+ /* key has not been created yet */
+ if (pthread_key_create(&pool_key, pool_destructor) != 0) {
+ gf_log("mem-pool", GF_LOG_CRITICAL,
+ "failed to initialize mem-pool key");
+ }
+
+ init_done = GF_MEMPOOL_INIT_EARLY;
+ } else {
+ gf_log("mem-pool", GF_LOG_CRITICAL,
+ "incorrect order of mem-pool initialization "
+ "(init_done=%d)",
+ init_done);
+ }
+
+ pthread_mutex_unlock(&init_mutex);
}
/* Call mem_pools_init_late() once threading has been configured completely.
* This prevent the pool_sweeper thread from getting killed once the main()
* thread exits during deamonizing. */
void
-mem_pools_init_late (void)
+mem_pools_init_late(void)
{
- pthread_mutex_lock (&init_mutex);
- if ((init_count++) == 0) {
- (void) gf_thread_create (&sweeper_tid, NULL, pool_sweeper,
- NULL, "memsweep");
-
- init_done = GF_MEMPOOL_INIT_LATE;
- }
- pthread_mutex_unlock (&init_mutex);
+ pthread_mutex_lock(&init_mutex);
+ if ((init_count++) == 0) {
+ (void)gf_thread_create(&sweeper_tid, NULL, pool_sweeper, NULL,
+ "memsweep");
+
+ init_done = GF_MEMPOOL_INIT_LATE;
+ }
+ pthread_mutex_unlock(&init_mutex);
}
void
-mem_pools_fini (void)
+mem_pools_fini(void)
{
- pthread_mutex_lock (&init_mutex);
- switch (init_count) {
+ pthread_mutex_lock(&init_mutex);
+ switch (init_count) {
case 0:
- /*
- * If init_count is already zero (as e.g. if somebody called
- * this before mem_pools_init_late) then the sweeper was
- * probably never even started so we don't need to stop it.
- * Even if there's some crazy circumstance where there is a
- * sweeper but init_count is still zero, that just means we'll
- * leave it running. Not perfect, but far better than any
- * known alternative.
- */
- break;
- case 1:
- {
- per_thread_pool_list_t *pool_list;
- per_thread_pool_list_t *next_pl;
- unsigned int i;
-
- /* if only mem_pools_init_early() was called, sweeper_tid will
- * be invalid and the functions will error out. That is not
- * critical. In all other cases, the sweeper_tid will be valid
- * and the thread gets stopped. */
- (void) pthread_cancel (sweeper_tid);
- (void) pthread_join (sweeper_tid, NULL);
-
- /* Need to clean the pool_key to prevent further usage of the
- * per_thread_pool_list_t structure that is stored for each
- * thread.
- * This also prevents calling pool_destructor() when a thread
- * exits, so there is no chance on a use-after-free of the
- * per_thread_pool_list_t structure. */
- (void) pthread_key_delete (pool_key);
-
- /* free all objects from all pools */
- list_for_each_entry_safe (pool_list, next_pl,
- &pool_threads, thr_list) {
- for (i = 0; i < NPOOLS; ++i) {
- free_obj_list (pool_list->pools[i].hot_list);
- free_obj_list (pool_list->pools[i].cold_list);
- pool_list->pools[i].hot_list = NULL;
- pool_list->pools[i].cold_list = NULL;
- }
-
- list_del (&pool_list->thr_list);
- FREE (pool_list);
+ /*
+ * If init_count is already zero (as e.g. if somebody called
+ * this before mem_pools_init_late) then the sweeper was
+ * probably never even started so we don't need to stop it.
+ * Even if there's some crazy circumstance where there is a
+ * sweeper but init_count is still zero, that just means we'll
+ * leave it running. Not perfect, but far better than any
+ * known alternative.
+ */
+ break;
+ case 1: {
+ per_thread_pool_list_t *pool_list;
+ per_thread_pool_list_t *next_pl;
+ unsigned int i;
+
+ /* if only mem_pools_init_early() was called, sweeper_tid will
+ * be invalid and the functions will error out. That is not
+ * critical. In all other cases, the sweeper_tid will be valid
+ * and the thread gets stopped. */
+ (void)pthread_cancel(sweeper_tid);
+ (void)pthread_join(sweeper_tid, NULL);
+
+ /* Need to clean the pool_key to prevent further usage of the
+ * per_thread_pool_list_t structure that is stored for each
+ * thread.
+ * This also prevents calling pool_destructor() when a thread
+ * exits, so there is no chance on a use-after-free of the
+ * per_thread_pool_list_t structure. */
+ (void)pthread_key_delete(pool_key);
+
+ /* free all objects from all pools */
+ list_for_each_entry_safe(pool_list, next_pl, &pool_threads,
+ thr_list)
+ {
+ for (i = 0; i < NPOOLS; ++i) {
+ free_obj_list(pool_list->pools[i].hot_list);
+ free_obj_list(pool_list->pools[i].cold_list);
+ pool_list->pools[i].hot_list = NULL;
+ pool_list->pools[i].cold_list = NULL;
}
- list_for_each_entry_safe (pool_list, next_pl,
- &pool_free_threads, thr_list) {
- list_del (&pool_list->thr_list);
- FREE (pool_list);
- }
+ list_del(&pool_list->thr_list);
+ FREE(pool_list);
+ }
- init_done = GF_MEMPOOL_INIT_DESTROY;
- /* Fall through. */
+ list_for_each_entry_safe(pool_list, next_pl, &pool_free_threads,
+ thr_list)
+ {
+ list_del(&pool_list->thr_list);
+ FREE(pool_list);
+ }
+
+ init_done = GF_MEMPOOL_INIT_DESTROY;
+ /* Fall through. */
}
default:
- --init_count;
- }
- pthread_mutex_unlock (&init_mutex);
+ --init_count;
+ }
+ pthread_mutex_unlock(&init_mutex);
}
#else
-void mem_pools_init_early (void) {}
-void mem_pools_init_late (void) {}
-void mem_pools_fini (void) {}
+void
+mem_pools_init_early(void)
+{
+}
+void
+mem_pools_init_late(void)
+{
+}
+void
+mem_pools_fini(void)
+{
+}
#endif
struct mem_pool *
-mem_pool_new_fn (glusterfs_ctx_t *ctx, unsigned long sizeof_type,
- unsigned long count, char *name)
+mem_pool_new_fn(glusterfs_ctx_t *ctx, unsigned long sizeof_type,
+ unsigned long count, char *name)
{
- unsigned int i;
- struct mem_pool *new = NULL;
- struct mem_pool_shared *pool = NULL;
-
- if (!sizeof_type) {
- gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
- LG_MSG_INVALID_ARG, "invalid argument");
- return NULL;
- }
-
- for (i = 0; i < NPOOLS; ++i) {
- if (sizeof_type <= AVAILABLE_SIZE(pools[i].power_of_two)) {
- pool = &pools[i];
- break;
- }
- }
-
- if (!pool) {
- gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
- LG_MSG_INVALID_ARG, "invalid argument");
- return NULL;
- }
-
- new = GF_CALLOC (sizeof (struct mem_pool), 1, gf_common_mt_mem_pool);
- if (!new)
- return NULL;
-
- new->ctx = ctx;
- new->sizeof_type = sizeof_type;
- new->count = count;
- new->name = name;
- new->pool = pool;
- GF_ATOMIC_INIT (new->active, 0);
- INIT_LIST_HEAD (&new->owner);
-
- LOCK (&ctx->lock);
- {
- list_add (&new->owner, &ctx->mempool_list);
- }
- UNLOCK (&ctx->lock);
-
- return new;
+ unsigned int i;
+ struct mem_pool *new = NULL;
+ struct mem_pool_shared *pool = NULL;
+
+ if (!sizeof_type) {
+ gf_msg_callingfn("mem-pool", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+ "invalid argument");
+ return NULL;
+ }
+
+ for (i = 0; i < NPOOLS; ++i) {
+ if (sizeof_type <= AVAILABLE_SIZE(pools[i].power_of_two)) {
+ pool = &pools[i];
+ break;
+ }
+ }
+
+ if (!pool) {
+ gf_msg_callingfn("mem-pool", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+ "invalid argument");
+ return NULL;
+ }
+
+ new = GF_CALLOC(sizeof(struct mem_pool), 1, gf_common_mt_mem_pool);
+ if (!new)
+ return NULL;
+
+ new->ctx = ctx;
+ new->sizeof_type = sizeof_type;
+ new->count = count;
+ new->name = name;
+ new->pool = pool;
+ GF_ATOMIC_INIT(new->active, 0);
+ INIT_LIST_HEAD(&new->owner);
+
+ LOCK(&ctx->lock);
+ {
+ list_add(&new->owner, &ctx->mempool_list);
+ }
+ UNLOCK(&ctx->lock);
+
+ return new;
}
-void*
-mem_get0 (struct mem_pool *mem_pool)
+void *
+mem_get0(struct mem_pool *mem_pool)
{
- void *ptr = NULL;
+ void *ptr = NULL;
- if (!mem_pool) {
- gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
- LG_MSG_INVALID_ARG, "invalid argument");
- return NULL;
- }
+ if (!mem_pool) {
+ gf_msg_callingfn("mem-pool", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+ "invalid argument");
+ return NULL;
+ }
- ptr = mem_get(mem_pool);
- if (ptr) {
+ ptr = mem_get(mem_pool);
+ if (ptr) {
#if defined(GF_DISABLE_MEMPOOL)
- memset (ptr, 0, mem_pool->sizeof_type);
+ memset(ptr, 0, mem_pool->sizeof_type);
#else
- memset (ptr, 0, AVAILABLE_SIZE(mem_pool->pool->power_of_two));
+ memset(ptr, 0, AVAILABLE_SIZE(mem_pool->pool->power_of_two));
#endif
- }
+ }
- return ptr;
+ return ptr;
}
-
per_thread_pool_list_t *
-mem_get_pool_list (void)
+mem_get_pool_list(void)
{
- per_thread_pool_list_t *pool_list;
- unsigned int i;
-
- pool_list = pthread_getspecific (pool_key);
- if (pool_list) {
- return pool_list;
- }
-
- (void) pthread_mutex_lock (&pool_free_lock);
- if (!list_empty (&pool_free_threads)) {
- pool_list = list_entry (pool_free_threads.next,
- per_thread_pool_list_t, thr_list);
- list_del (&pool_list->thr_list);
- }
- (void) pthread_mutex_unlock (&pool_free_lock);
+ per_thread_pool_list_t *pool_list;
+ unsigned int i;
+ pool_list = pthread_getspecific(pool_key);
+ if (pool_list) {
+ return pool_list;
+ }
+
+ (void)pthread_mutex_lock(&pool_free_lock);
+ if (!list_empty(&pool_free_threads)) {
+ pool_list = list_entry(pool_free_threads.next, per_thread_pool_list_t,
+ thr_list);
+ list_del(&pool_list->thr_list);
+ }
+ (void)pthread_mutex_unlock(&pool_free_lock);
+
+ if (!pool_list) {
+ pool_list = CALLOC(pool_list_size, 1);
if (!pool_list) {
- pool_list = CALLOC (pool_list_size, 1);
- if (!pool_list) {
- return NULL;
- }
+ return NULL;
+ }
- INIT_LIST_HEAD (&pool_list->thr_list);
- (void) pthread_spin_init (&pool_list->lock,
- PTHREAD_PROCESS_PRIVATE);
- for (i = 0; i < NPOOLS; ++i) {
- pool_list->pools[i].parent = &pools[i];
- pool_list->pools[i].hot_list = NULL;
- pool_list->pools[i].cold_list = NULL;
- }
+ INIT_LIST_HEAD(&pool_list->thr_list);
+ (void)pthread_spin_init(&pool_list->lock, PTHREAD_PROCESS_PRIVATE);
+ for (i = 0; i < NPOOLS; ++i) {
+ pool_list->pools[i].parent = &pools[i];
+ pool_list->pools[i].hot_list = NULL;
+ pool_list->pools[i].cold_list = NULL;
}
+ }
- (void) pthread_mutex_lock (&pool_lock);
- pool_list->poison = 0;
- list_add (&pool_list->thr_list, &pool_threads);
- (void) pthread_mutex_unlock (&pool_lock);
+ (void)pthread_mutex_lock(&pool_lock);
+ pool_list->poison = 0;
+ list_add(&pool_list->thr_list, &pool_threads);
+ (void)pthread_mutex_unlock(&pool_lock);
- (void) pthread_setspecific (pool_key, pool_list);
- return pool_list;
+ (void)pthread_setspecific(pool_key, pool_list);
+ return pool_list;
}
pooled_obj_hdr_t *
-mem_get_from_pool (per_thread_pool_t *pt_pool)
+mem_get_from_pool(per_thread_pool_t *pt_pool)
{
- pooled_obj_hdr_t *retval;
-
- retval = pt_pool->hot_list;
- if (retval) {
- GF_ATOMIC_INC (pt_pool->parent->allocs_hot);
- pt_pool->hot_list = retval->next;
- return retval;
- }
-
- retval = pt_pool->cold_list;
- if (retval) {
- GF_ATOMIC_INC (pt_pool->parent->allocs_cold);
- pt_pool->cold_list = retval->next;
- return retval;
- }
-
- GF_ATOMIC_INC (pt_pool->parent->allocs_stdc);
- return malloc (1 << pt_pool->parent->power_of_two);
+ pooled_obj_hdr_t *retval;
+
+ retval = pt_pool->hot_list;
+ if (retval) {
+ GF_ATOMIC_INC(pt_pool->parent->allocs_hot);
+ pt_pool->hot_list = retval->next;
+ return retval;
+ }
+
+ retval = pt_pool->cold_list;
+ if (retval) {
+ GF_ATOMIC_INC(pt_pool->parent->allocs_cold);
+ pt_pool->cold_list = retval->next;
+ return retval;
+ }
+
+ GF_ATOMIC_INC(pt_pool->parent->allocs_stdc);
+ return malloc(1 << pt_pool->parent->power_of_two);
}
-
void *
-mem_get (struct mem_pool *mem_pool)
+mem_get(struct mem_pool *mem_pool)
{
#if defined(GF_DISABLE_MEMPOOL)
- return GF_MALLOC (mem_pool->sizeof_type, gf_common_mt_mem_pool);
+ return GF_MALLOC(mem_pool->sizeof_type, gf_common_mt_mem_pool);
#else
- per_thread_pool_list_t *pool_list;
- per_thread_pool_t *pt_pool;
- pooled_obj_hdr_t *retval;
-
- if (!mem_pool) {
- gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
- LG_MSG_INVALID_ARG, "invalid argument");
- return NULL;
- }
-
- pool_list = mem_get_pool_list ();
- if (!pool_list || pool_list->poison) {
- return NULL;
- }
-
- (void) pthread_spin_lock (&pool_list->lock);
- pt_pool = &pool_list->pools[mem_pool->pool->power_of_two-POOL_SMALLEST];
- retval = mem_get_from_pool (pt_pool);
-
- if (!retval) {
- (void) pthread_spin_unlock (&pool_list->lock);
- return NULL;
- }
-
- retval->magic = GF_MEM_HEADER_MAGIC;
- retval->pool = mem_pool;
- retval->pool_list = pool_list;
- retval->power_of_two = mem_pool->pool->power_of_two;
- (void) pthread_spin_unlock (&pool_list->lock);
-
- GF_ATOMIC_INC (mem_pool->active);
-
- return retval + 1;
+ per_thread_pool_list_t *pool_list;
+ per_thread_pool_t *pt_pool;
+ pooled_obj_hdr_t *retval;
+
+ if (!mem_pool) {
+ gf_msg_callingfn("mem-pool", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+ "invalid argument");
+ return NULL;
+ }
+
+ pool_list = mem_get_pool_list();
+ if (!pool_list || pool_list->poison) {
+ return NULL;
+ }
+
+ (void)pthread_spin_lock(&pool_list->lock);
+ pt_pool = &pool_list->pools[mem_pool->pool->power_of_two - POOL_SMALLEST];
+ retval = mem_get_from_pool(pt_pool);
+
+ if (!retval) {
+ (void)pthread_spin_unlock(&pool_list->lock);
+ return NULL;
+ }
+
+ retval->magic = GF_MEM_HEADER_MAGIC;
+ retval->pool = mem_pool;
+ retval->pool_list = pool_list;
+ retval->power_of_two = mem_pool->pool->power_of_two;
+ (void)pthread_spin_unlock(&pool_list->lock);
+
+ GF_ATOMIC_INC(mem_pool->active);
+
+ return retval + 1;
#endif /* GF_DISABLE_MEMPOOL */
}
-
void
-mem_put (void *ptr)
+mem_put(void *ptr)
{
#if defined(GF_DISABLE_MEMPOOL)
- GF_FREE (ptr);
+ GF_FREE(ptr);
#else
- pooled_obj_hdr_t *hdr;
- per_thread_pool_list_t *pool_list;
- per_thread_pool_t *pt_pool;
-
- if (!ptr) {
- gf_msg_callingfn ("mem-pool", GF_LOG_ERROR, EINVAL,
- LG_MSG_INVALID_ARG, "invalid argument");
- return;
- }
-
- hdr = ((pooled_obj_hdr_t *)ptr) - 1;
- if (hdr->magic != GF_MEM_HEADER_MAGIC) {
- /* Not one of ours; don't touch it. */
- return;
- }
- pool_list = hdr->pool_list;
- pt_pool = &pool_list->pools[hdr->power_of_two-POOL_SMALLEST];
+ pooled_obj_hdr_t *hdr;
+ per_thread_pool_list_t *pool_list;
+ per_thread_pool_t *pt_pool;
- GF_ATOMIC_DEC (hdr->pool->active);
+ if (!ptr) {
+ gf_msg_callingfn("mem-pool", GF_LOG_ERROR, EINVAL, LG_MSG_INVALID_ARG,
+ "invalid argument");
+ return;
+ }
- (void) pthread_spin_lock (&pool_list->lock);
- hdr->magic = GF_MEM_INVALID_MAGIC;
- hdr->next = pt_pool->hot_list;
- pt_pool->hot_list = hdr;
- GF_ATOMIC_INC (pt_pool->parent->frees_to_list);
- (void) pthread_spin_unlock (&pool_list->lock);
+ hdr = ((pooled_obj_hdr_t *)ptr) - 1;
+ if (hdr->magic != GF_MEM_HEADER_MAGIC) {
+ /* Not one of ours; don't touch it. */
+ return;
+ }
+ pool_list = hdr->pool_list;
+ pt_pool = &pool_list->pools[hdr->power_of_two - POOL_SMALLEST];
+
+ GF_ATOMIC_DEC(hdr->pool->active);
+
+ (void)pthread_spin_lock(&pool_list->lock);
+ hdr->magic = GF_MEM_INVALID_MAGIC;
+ hdr->next = pt_pool->hot_list;
+ pt_pool->hot_list = hdr;
+ GF_ATOMIC_INC(pt_pool->parent->frees_to_list);
+ (void)pthread_spin_unlock(&pool_list->lock);
#endif /* GF_DISABLE_MEMPOOL */
}
void
-mem_pool_destroy (struct mem_pool *pool)
+mem_pool_destroy(struct mem_pool *pool)
{
- if (!pool)
- return;
-
- /* remove this pool from the owner (glusterfs_ctx_t) */
- LOCK (&pool->ctx->lock);
- {
- list_del (&pool->owner);
- }
- UNLOCK (&pool->ctx->lock);
-
- /* free this pool, but keep the mem_pool_shared */
- GF_FREE (pool);
+ if (!pool)
+ return;
- /*
- * Pools are now permanent, so the mem_pool->pool is kept around. All
- * of the objects *in* the pool will eventually be freed via the
- * pool-sweeper thread, and this way we don't have to add a lot of
- * reference-counting complexity.
- */
+ /* remove this pool from the owner (glusterfs_ctx_t) */
+ LOCK(&pool->ctx->lock);
+ {
+ list_del(&pool->owner);
+ }
+ UNLOCK(&pool->ctx->lock);
+
+ /* free this pool, but keep the mem_pool_shared */
+ GF_FREE(pool);
+
+ /*
+ * Pools are now permanent, so the mem_pool->pool is kept around. All
+ * of the objects *in* the pool will eventually be freed via the
+ * pool-sweeper thread, and this way we don't have to add a lot of
+ * reference-counting complexity.
+ */
}