1 struct mem_pool * 2 mem_pool_new_fn (unsigned long sizeof_type, 3                  unsigned long count, char *name) 4 { 5         struct mem_pool  *mem_pool = NULL; 6         unsigned long     padded_sizeof_type = 0; 7         void             *pool = NULL; 8         int               i = 0; 9         int               ret = 0;10         struct list_head *list = NULL;11         glusterfs_ctx_t  *ctx = NULL;12 13         if (!sizeof_type || !count) {14                 gf_log_callingfn ("mem-pool", GF_LOG_ERROR, "invalid argument");15                 return NULL;16         }17         padded_sizeof_type = sizeof_type + GF_MEM_POOL_PAD_BOUNDARY;18 19         mem_pool = GF_CALLOC (sizeof (*mem_pool), 1, gf_common_mt_mem_pool);20         if (!mem_pool)21                 return NULL;22 23         ret = gf_asprintf (&mem_pool->name, "%s:%s", THIS->name, name);24         if (ret < 0)25                 return NULL;26 27         if (!mem_pool->name) {28                 GF_FREE (mem_pool);29                 return NULL;30         }31 32         LOCK_INIT (&mem_pool->lock);33         INIT_LIST_HEAD (&mem_pool->list);34         INIT_LIST_HEAD (&mem_pool->global_list);35 36         mem_pool->padded_sizeof_type = padded_sizeof_type;37         mem_pool->cold_count = count;38         mem_pool->real_sizeof_type = sizeof_type;39 40         pool = GF_CALLOC (count, padded_sizeof_type, gf_common_mt_long);41         if (!pool) {42                 GF_FREE (mem_pool->name);43                 GF_FREE (mem_pool);44                 return NULL;45         }46 47         for (i = 0; i < count; i++) {48                 list = pool + (i * (padded_sizeof_type));49                 INIT_LIST_HEAD (list);50                 list_add_tail (list, &mem_pool->list);51         }52 53         mem_pool->pool = pool;54         mem_pool->pool_end = pool + (count * (padded_sizeof_type));55 56         /* add this pool to the global list */57         ctx = THIS->ctx;58         if (!ctx)59                 goto out;60 61         list_add (&mem_pool->global_list, &ctx->mempool_list);62 63 out:64         return mem_pool;65 }

 1 void * 2 mem_get (struct mem_pool *mem_pool) 3 { 4         struct list_head *list = NULL; 5         void             *ptr = NULL; 6         int             *in_use = NULL; 7         struct mem_pool **pool_ptr = NULL; 8  9         if (!mem_pool) {10                 gf_log_callingfn ("mem-pool", GF_LOG_ERROR, "invalid argument");11                 return NULL;12         }13 14         LOCK (&mem_pool->lock);15         {16                 mem_pool->alloc_count++;17                 if (mem_pool->cold_count) {18                         list = mem_pool->list.next;19                         list_del (list);20 21                         mem_pool->hot_count++;22                         mem_pool->cold_count--;23 24                         if (mem_pool->max_alloc < mem_pool->hot_count)25                                 mem_pool->max_alloc = mem_pool->hot_count;26 27                         ptr = list;28                         in_use = (ptr + GF_MEM_POOL_LIST_BOUNDARY +29                                   GF_MEM_POOL_PTR);30                         *in_use = 1;31 32                         goto fwd_addr_out;33                 }34 35                 /* This is a problem area. If we‘ve run out of36                  * chunks in our slab above, we need to allocate37                  * enough memory to service this request.38                  * The problem is, these individual chunks will fail39                  * the first address range check in __is_member. Now, since40                  * we‘re not allocating a full second slab, we wont have41                  * enough info perform the range check in __is_member.42                  *43                  * I am working around this by performing a regular allocation44                  * , just the way the caller would‘ve done when not using the45                  * mem-pool. That also means, we‘re not padding the size with46                  * the list_head structure because, this will not be added to47                  * the list of chunks that belong to the mem-pool allocated48                  * initially.49                  *50                  * This is the best we can do without adding functionality for51                  * managing multiple slabs. That does not interest us at present52                  * because it is too much work knowing that a better slab53                  * allocator is coming RSN.54                  */55                 mem_pool->pool_misses++;56                 mem_pool->curr_stdalloc++;57                 if (mem_pool->max_stdalloc < mem_pool->curr_stdalloc)58                         mem_pool->max_stdalloc = mem_pool->curr_stdalloc;59                 ptr = GF_CALLOC (1, mem_pool->padded_sizeof_type,60                                  gf_common_mt_mem_pool);61                 gf_log_callingfn ("mem-pool", GF_LOG_DEBUG, "Mem pool is full. "62                                   "Callocing mem");63 64                 /* Memory coming from the heap need not be transformed from a65                  * chunkhead to a usable pointer since it is not coming from66                  * the pool.67                  */68         }69 fwd_addr_out:70         pool_ptr = mem_pool_from_ptr (ptr);71         *pool_ptr = (struct mem_pool *)mem_pool;72         ptr = mem_pool_chunkhead2ptr (ptr);73         UNLOCK (&mem_pool->lock);74 75         return ptr;76 }

 1 void 2 mem_put (void *ptr) 3 { 4         struct list_head *list = NULL; 5         int    *in_use = NULL; 6         void   *head = NULL; 7         struct mem_pool **tmp = NULL; 8         struct mem_pool *pool = NULL; 9 10         if (!ptr) {11                 gf_log_callingfn ("mem-pool", GF_LOG_ERROR, "invalid argument");12                 return;13         }14 15         list = head = mem_pool_ptr2chunkhead (ptr);16         tmp = mem_pool_from_ptr (head);17         if (!tmp) {18                 gf_log_callingfn ("mem-pool", GF_LOG_ERROR,19                                   "ptr header is corrupted");20                 return;21         }22 23         pool = *tmp;24         if (!pool) {25                 gf_log_callingfn ("mem-pool", GF_LOG_ERROR,26                                   "mem-pool ptr is NULL");27                 return;28         }29         LOCK (&pool->lock);30         {31 32                 switch (__is_member (pool, ptr))33                 {34                 case 1:35                         in_use = (head + GF_MEM_POOL_LIST_BOUNDARY +36                                   GF_MEM_POOL_PTR);37                         if (!is_mem_chunk_in_use(in_use)) {38                                 gf_log_callingfn ("mem-pool", GF_LOG_CRITICAL,39                                                   "mem_put called on freed ptr %p of mem "40                                                   "pool %p", ptr, pool);41                                 break;42                         }43                         pool->hot_count--;44                         pool->cold_count++;45                         *in_use = 0;46                         list_add (list, &pool->list);47                         break;48                 case -1:49                         /* For some reason, the address given is within50                          * the address range of the mem-pool but does not align51                          * with the expected start of a chunk that includes52                          * the list headers also. Sounds like a problem in53                          * layers of clouds up above us. ;)54                          */55                         abort ();56                         break;57                 case 0:58                         /* The address is outside the range of the mem-pool. We59                          * assume here that this address was allocated at a60                          * point when the mem-pool was out of chunks in mem_get61                          * or the programmer has made a mistake by calling the62                          * wrong de-allocation interface. We do63                          * not have enough info to distinguish between the two64                          * situations.65                          */66                         pool->curr_stdalloc--;67                         GF_FREE (list);68                         break;69                 default:70                         /* log error */71                         break;72                 }73         }74         UNLOCK (&pool->lock);75 }