blob: fcd7679314f2ca9df997dd9887e9130a20a6c47c [file] [log] [blame]
Willy Tarreau50e608d2007-05-13 18:26:08 +02001/*
2 * Memory management functions.
3 *
4 * Copyright 2000-2007 Willy Tarreau <w@1wt.eu>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreau12833bb2014-01-28 16:49:56 +010013#include <types/global.h>
Willy Tarreau50e608d2007-05-13 18:26:08 +020014#include <common/config.h>
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +020015#include <common/debug.h>
Willy Tarreau50e608d2007-05-13 18:26:08 +020016#include <common/memory.h>
17#include <common/mini-clist.h>
18#include <common/standard.h>
19
20#include <proto/log.h>
21
22static struct list pools = LIST_HEAD_INIT(pools);
Willy Tarreau6e064432012-05-08 15:40:42 +020023char mem_poison_byte = 0;
Willy Tarreau50e608d2007-05-13 18:26:08 +020024
25/* Try to find an existing shared pool with the same characteristics and
26 * returns it, otherwise creates this one. NULL is returned if no memory
27 * is available for a new creation.
28 */
29struct pool_head *create_pool(char *name, unsigned int size, unsigned int flags)
30{
31 struct pool_head *pool;
Willy Tarreau7dcd46d2007-05-14 00:16:13 +020032 struct pool_head *entry;
33 struct list *start;
Willy Tarreau50e608d2007-05-13 18:26:08 +020034 unsigned int align;
35
36 /* We need to store at least a (void *) in the chunks. Since we know
37 * that the malloc() function will never return such a small size,
38 * let's round the size up to something slightly bigger, in order to
39 * ease merging of entries. Note that the rounding is a power of two.
40 */
41
Willy Tarreau7dcd46d2007-05-14 00:16:13 +020042 align = 16;
Willy Tarreau50e608d2007-05-13 18:26:08 +020043 size = (size + align - 1) & -align;
44
Willy Tarreau7dcd46d2007-05-14 00:16:13 +020045 start = &pools;
Willy Tarreau50e608d2007-05-13 18:26:08 +020046 pool = NULL;
Willy Tarreau7dcd46d2007-05-14 00:16:13 +020047
48 list_for_each_entry(entry, &pools, list) {
49 if (entry->size == size) {
50 /* either we can share this place and we take it, or
51 * we look for a sharable one or for the next position
52 * before which we will insert a new one.
53 */
54 if (flags & entry->flags & MEM_F_SHARED) {
55 /* we can share this one */
Willy Tarreau50e608d2007-05-13 18:26:08 +020056 pool = entry;
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +020057 DPRINTF(stderr, "Sharing %s with %s\n", name, pool->name);
Willy Tarreau50e608d2007-05-13 18:26:08 +020058 break;
59 }
60 }
Willy Tarreau7dcd46d2007-05-14 00:16:13 +020061 else if (entry->size > size) {
62 /* insert before this one */
63 start = &entry->list;
64 break;
65 }
Willy Tarreau50e608d2007-05-13 18:26:08 +020066 }
67
68 if (!pool) {
69 pool = CALLOC(1, sizeof(*pool));
70 if (!pool)
71 return NULL;
72 if (name)
73 strlcpy2(pool->name, name, sizeof(pool->name));
74 pool->size = size;
75 pool->flags = flags;
Willy Tarreau7dcd46d2007-05-14 00:16:13 +020076 LIST_ADDQ(start, &pool->list);
Willy Tarreau50e608d2007-05-13 18:26:08 +020077 }
Willy Tarreau7dcd46d2007-05-14 00:16:13 +020078 pool->users++;
Willy Tarreau50e608d2007-05-13 18:26:08 +020079 return pool;
80}
81
82/* Allocate a new entry for pool <pool>, and return it for immediate use.
Willy Tarreau7dcd46d2007-05-14 00:16:13 +020083 * NULL is returned if no memory is available for a new creation. A call
84 * to the garbage collector is performed before returning NULL.
Willy Tarreau50e608d2007-05-13 18:26:08 +020085 */
Willy Tarreaue6ce59d2007-05-13 19:38:49 +020086void *pool_refill_alloc(struct pool_head *pool)
Willy Tarreau50e608d2007-05-13 18:26:08 +020087{
88 void *ret;
89
90 if (pool->limit && (pool->allocated >= pool->limit))
91 return NULL;
Willy Tarreau6e064432012-05-08 15:40:42 +020092 ret = CALLOC(1, pool->size);
Willy Tarreau7dcd46d2007-05-14 00:16:13 +020093 if (!ret) {
94 pool_gc2();
Willy Tarreau6e064432012-05-08 15:40:42 +020095 ret = CALLOC(1, pool->size);
Willy Tarreau7dcd46d2007-05-14 00:16:13 +020096 if (!ret)
97 return NULL;
98 }
Willy Tarreau6e064432012-05-08 15:40:42 +020099 if (mem_poison_byte)
100 memset(ret, mem_poison_byte, pool->size);
Willy Tarreau50e608d2007-05-13 18:26:08 +0200101 pool->allocated++;
102 pool->used++;
103 return ret;
104}
105
Willy Tarreaue6ce59d2007-05-13 19:38:49 +0200106/*
107 * This function frees whatever can be freed in pool <pool>.
108 */
109void pool_flush2(struct pool_head *pool)
110{
111 void *temp, *next;
Willy Tarreau4d2d0982007-05-14 00:39:29 +0200112 if (!pool)
113 return;
114
Willy Tarreaue6ce59d2007-05-13 19:38:49 +0200115 next = pool->free_list;
116 while (next) {
117 temp = next;
118 next = *(void **)temp;
119 pool->allocated--;
120 FREE(temp);
121 }
122 pool->free_list = next;
123
124 /* here, we should have pool->allocate == pool->used */
125}
126
127/*
128 * This function frees whatever can be freed in all pools, but respecting
Willy Tarreaub7f9d122009-04-21 02:17:45 +0200129 * the minimum thresholds imposed by owners. It takes care of avoiding
130 * recursion because it may be called from a signal handler.
Willy Tarreaue6ce59d2007-05-13 19:38:49 +0200131 */
132void pool_gc2()
133{
Willy Tarreaub7f9d122009-04-21 02:17:45 +0200134 static int recurse;
Willy Tarreaue6ce59d2007-05-13 19:38:49 +0200135 struct pool_head *entry;
Willy Tarreaub7f9d122009-04-21 02:17:45 +0200136
137 if (recurse++)
138 goto out;
139
Willy Tarreaue6ce59d2007-05-13 19:38:49 +0200140 list_for_each_entry(entry, &pools, list) {
141 void *temp, *next;
142 //qfprintf(stderr, "Flushing pool %s\n", entry->name);
143 next = entry->free_list;
144 while (next &&
Willy Tarreau57767b82014-12-22 21:40:55 +0100145 (int)(entry->allocated - entry->used) > (int)entry->minavail) {
Willy Tarreaue6ce59d2007-05-13 19:38:49 +0200146 temp = next;
147 next = *(void **)temp;
148 entry->allocated--;
149 FREE(temp);
150 }
151 entry->free_list = next;
152 }
Willy Tarreaub7f9d122009-04-21 02:17:45 +0200153 out:
154 recurse--;
Willy Tarreaue6ce59d2007-05-13 19:38:49 +0200155}
156
157/*
Willy Tarreaudae4aa82007-06-16 23:19:53 +0200158 * This function destroys a pool by freeing it completely, unless it's still
159 * in use. This should be called only under extreme circumstances. It always
160 * returns NULL if the resulting pool is empty, easing the clearing of the old
161 * pointer, otherwise it returns the pool.
162 * .
Willy Tarreaue6ce59d2007-05-13 19:38:49 +0200163 */
Willy Tarreau4d2d0982007-05-14 00:39:29 +0200164void *pool_destroy2(struct pool_head *pool)
Willy Tarreaue6ce59d2007-05-13 19:38:49 +0200165{
Willy Tarreau4d2d0982007-05-14 00:39:29 +0200166 if (pool) {
167 pool_flush2(pool);
Willy Tarreaudae4aa82007-06-16 23:19:53 +0200168 if (pool->used)
169 return pool;
170 pool->users--;
171 if (!pool->users) {
172 LIST_DEL(&pool->list);
173 FREE(pool);
174 }
Willy Tarreau4d2d0982007-05-14 00:39:29 +0200175 }
176 return NULL;
Willy Tarreaue6ce59d2007-05-13 19:38:49 +0200177}
178
Willy Tarreau12833bb2014-01-28 16:49:56 +0100179/* This function dumps memory usage information into the trash buffer. */
180void dump_pools_to_trash()
Willy Tarreau50e608d2007-05-13 18:26:08 +0200181{
182 struct pool_head *entry;
183 unsigned long allocated, used;
184 int nbpools;
185
186 allocated = used = nbpools = 0;
Willy Tarreau12833bb2014-01-28 16:49:56 +0100187 chunk_printf(&trash, "Dumping pools usage. Use SIGQUIT to flush them.\n");
Willy Tarreau50e608d2007-05-13 18:26:08 +0200188 list_for_each_entry(entry, &pools, list) {
Willy Tarreau12833bb2014-01-28 16:49:56 +0100189 chunk_appendf(&trash, " - Pool %s (%d bytes) : %d allocated (%u bytes), %d used, %d users%s\n",
Willy Tarreaue6ce59d2007-05-13 19:38:49 +0200190 entry->name, entry->size, entry->allocated,
191 entry->size * entry->allocated, entry->used,
Willy Tarreau7dcd46d2007-05-14 00:16:13 +0200192 entry->users, (entry->flags & MEM_F_SHARED) ? " [SHARED]" : "");
Willy Tarreau50e608d2007-05-13 18:26:08 +0200193
194 allocated += entry->allocated * entry->size;
195 used += entry->used * entry->size;
196 nbpools++;
197 }
Willy Tarreau12833bb2014-01-28 16:49:56 +0100198 chunk_appendf(&trash, "Total: %d pools, %lu bytes allocated, %lu used.\n",
Willy Tarreau50e608d2007-05-13 18:26:08 +0200199 nbpools, allocated, used);
200}
201
Willy Tarreau12833bb2014-01-28 16:49:56 +0100202/* Dump statistics on pools usage. */
203void dump_pools(void)
204{
205 dump_pools_to_trash();
206 qfprintf(stderr, "%s", trash.str);
207}
208
Willy Tarreau50e608d2007-05-13 18:26:08 +0200209/*
210 * Local variables:
211 * c-indent-level: 8
212 * c-basic-offset: 8
213 * End:
214 */