konevsa/haproxy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

CLEANUP: pools: rename all pool functions and pointers to remove this "2"

Browse Source 
During the migration to the second version of the pools, the new
functions and pool pointers were all called "pool_something2()" and
"pool2_something". Now there's no more pool v1 code and it's a real
pain to still have to deal with this. Let's clean this up now by
removing the "2" everywhere, and by renaming the pool heads
"pool_head_something".
This commit is contained in:
Willy Tarreau 2017-11-24 17:34:44 +01:00
parent fbc74e8556
commit bafbe01028
47 changed files with 308 additions and 308 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
doc/management.txt
View File

@ -192,7 +192,7 @@ list of options is :
difficult to troubleshoot. difficult to troubleshoot.
-dM[<byte>] : forces memory poisoning, which means that each and every -dM[<byte>] : forces memory poisoning, which means that each and every
memory region allocated with malloc() or pool_alloc2() will be filled with memory region allocated with malloc() or pool_alloc() will be filled with
<byte> before being passed to the caller. When <byte> is not specified, it <byte> before being passed to the caller. When <byte> is not specified, it
defaults to 0x50 ('P'). While this slightly slows down operations, it is defaults to 0x50 ('P'). While this slightly slows down operations, it is
useful to reliably trigger issues resulting from missing initializations in useful to reliably trigger issues resulting from missing initializations in

28
include/common/buffer.h
View File

@ -48,7 +48,7 @@ struct buffer_wait {
struct list list; /* Next element in the <buffer_wq> list */ struct list list; /* Next element in the <buffer_wq> list */
}; };
extern struct pool_head *pool2_buffer; extern struct pool_head *pool_head_buffer;
extern struct buffer buf_empty; extern struct buffer buf_empty;
extern struct buffer buf_wanted; extern struct buffer buf_wanted;
extern struct list buffer_wq; extern struct list buffer_wq;
@ -665,9 +665,9 @@ static inline struct buffer *b_alloc(struct buffer **buf)
struct buffer *b; struct buffer *b;
*buf = &buf_wanted; *buf = &buf_wanted;
b = pool_alloc_dirty(pool2_buffer); b = pool_alloc_dirty(pool_head_buffer);
if (likely(b)) { if (likely(b)) {
b->size = pool2_buffer->size - sizeof(struct buffer); b->size = pool_head_buffer->size - sizeof(struct buffer);
b_reset(b); b_reset(b);
*buf = b; *buf = b;
} }
@ -686,9 +686,9 @@ static inline struct buffer *b_alloc_fast(struct buffer **buf)
struct buffer *b; struct buffer *b;
*buf = &buf_wanted; *buf = &buf_wanted;
b = pool_get_first(pool2_buffer); b = pool_get_first(pool_head_buffer);
if (likely(b)) { if (likely(b)) {
b->size = pool2_buffer->size - sizeof(struct buffer); b->size = pool_head_buffer->size - sizeof(struct buffer);
b_reset(b); b_reset(b);
*buf = b; *buf = b;
} }
@ -698,7 +698,7 @@ static inline struct buffer *b_alloc_fast(struct buffer **buf)
/* Releases buffer *buf (no check of emptiness) */ /* Releases buffer *buf (no check of emptiness) */
static inline void __b_drop(struct buffer **buf) static inline void __b_drop(struct buffer **buf)
{ {
pool_free2(pool2_buffer, *buf); pool_free(pool_head_buffer, *buf);
} }
/* Releases buffer *buf if allocated. */ /* Releases buffer *buf if allocated. */
@ -735,14 +735,14 @@ static inline struct buffer *b_alloc_margin(struct buffer **buf, int margin)
return *buf; return *buf;
*buf = &buf_wanted; *buf = &buf_wanted;
HA_SPIN_LOCK(POOL_LOCK, &pool2_buffer->lock); HA_SPIN_LOCK(POOL_LOCK, &pool_head_buffer->lock);
/* fast path */ /* fast path */
if ((pool2_buffer->allocated - pool2_buffer->used) > margin) { if ((pool_head_buffer->allocated - pool_head_buffer->used) > margin) {
b = __pool_get_first(pool2_buffer); b = __pool_get_first(pool_head_buffer);
if (likely(b)) { if (likely(b)) {
HA_SPIN_UNLOCK(POOL_LOCK, &pool2_buffer->lock); HA_SPIN_UNLOCK(POOL_LOCK, &pool_head_buffer->lock);
b->size = pool2_buffer->size - sizeof(struct buffer); b->size = pool_head_buffer->size - sizeof(struct buffer);
b_reset(b); b_reset(b);
*buf = b; *buf = b;
return b; return b;
@ -750,12 +750,12 @@ static inline struct buffer *b_alloc_margin(struct buffer **buf, int margin)
} }
/* slow path, uses malloc() */ /* slow path, uses malloc() */
b = __pool_refill_alloc(pool2_buffer, margin); b = __pool_refill_alloc(pool_head_buffer, margin);
HA_SPIN_UNLOCK(POOL_LOCK, &pool2_buffer->lock); HA_SPIN_UNLOCK(POOL_LOCK, &pool_head_buffer->lock);
if (b) { if (b) {
b->size = pool2_buffer->size - sizeof(struct buffer); b->size = pool_head_buffer->size - sizeof(struct buffer);
b_reset(b); b_reset(b);
*buf = b; *buf = b;
} }

4
include/common/chunk.h
View File

@ -36,7 +36,7 @@ struct chunk {
int len; /* current size of the string from first to last char. <0 = uninit. */ int len; /* current size of the string from first to last char. <0 = uninit. */
}; };
struct pool_head *pool2_trash; struct pool_head *pool_head_trash;
/* function prototypes */ /* function prototypes */
@ -60,7 +60,7 @@ void deinit_trash_buffers(void);
*/ */
static inline void free_trash_chunk(struct chunk *chunk) static inline void free_trash_chunk(struct chunk *chunk)
{ {
pool_free2(pool2_trash, chunk); pool_free(pool_head_trash, chunk);
} }

12
include/common/memory.h
View File

@ -93,23 +93,23 @@ unsigned long pool_total_used();
/* /*
* This function frees whatever can be freed in pool <pool>. * This function frees whatever can be freed in pool <pool>.
*/ */
void pool_flush2(struct pool_head *pool); void pool_flush(struct pool_head *pool);
/* /*
* This function frees whatever can be freed in all pools, but respecting * This function frees whatever can be freed in all pools, but respecting
* the minimum thresholds imposed by owners. * the minimum thresholds imposed by owners.
* *
* <pool_ctx> is used when pool_gc2 is called to release resources to allocate * <pool_ctx> is used when pool_gc is called to release resources to allocate
* an element in __pool_refill_alloc. It is important because <pool_ctx> is * an element in __pool_refill_alloc. It is important because <pool_ctx> is
* already locked, so we need to skip the lock here. * already locked, so we need to skip the lock here.
*/ */
void pool_gc2(struct pool_head *pool_ctx); void pool_gc(struct pool_head *pool_ctx);
/* /*
* This function destroys a pull by freeing it completely. * This function destroys a pull by freeing it completely.
* This should be called only under extreme circumstances. * This should be called only under extreme circumstances.
*/ */
void *pool_destroy2(struct pool_head *pool); void *pool_destroy(struct pool_head *pool);
/* /*
* Returns a pointer to type <type> taken from the pool <pool_type> if * Returns a pointer to type <type> taken from the pool <pool_type> if
@ -209,7 +209,7 @@ static inline void pool_free_area(void *area, size_t size)
* dynamically allocated. In the first case, <pool_type> is updated to point to * dynamically allocated. In the first case, <pool_type> is updated to point to
* the next element in the list. Memory poisonning is performed if enabled. * the next element in the list. Memory poisonning is performed if enabled.
*/ */
static inline void *pool_alloc2(struct pool_head *pool) static inline void *pool_alloc(struct pool_head *pool)
{ {
void *p; void *p;
@ -238,7 +238,7 @@ static inline void *pool_alloc2(struct pool_head *pool)
* pointer. Just like with the libc's free(), nothing * pointer. Just like with the libc's free(), nothing
* is done if <ptr> is NULL. * is done if <ptr> is NULL.
*/ */
static inline void pool_free2(struct pool_head *pool, void *ptr) static inline void pool_free(struct pool_head *pool, void *ptr)
{ {
if (likely(ptr != NULL)) { if (likely(ptr != NULL)) {
HA_SPIN_LOCK(POOL_LOCK, &pool->lock); HA_SPIN_LOCK(POOL_LOCK, &pool->lock);

6
include/proto/applet.h
View File

@ -55,14 +55,14 @@ static inline void appctx_init(struct appctx *appctx, unsigned long thread_mask)
/* Tries to allocate a new appctx and initialize its main fields. The appctx /* Tries to allocate a new appctx and initialize its main fields. The appctx
* is returned on success, NULL on failure. The appctx must be released using * is returned on success, NULL on failure. The appctx must be released using
* pool_free2(connection) or appctx_free(), since it's allocated from the * pool_free(connection) or appctx_free(), since it's allocated from the
* connection pool. <applet> is assigned as the applet, but it can be NULL. * connection pool. <applet> is assigned as the applet, but it can be NULL.
*/ */
static inline struct appctx *appctx_new(struct applet *applet, unsigned long thread_mask) static inline struct appctx *appctx_new(struct applet *applet, unsigned long thread_mask)
{ {
struct appctx *appctx; struct appctx *appctx;
appctx = pool_alloc2(pool2_connection); appctx = pool_alloc(pool_head_connection);
if (likely(appctx != NULL)) { if (likely(appctx != NULL)) {
appctx->obj_type = OBJ_TYPE_APPCTX; appctx->obj_type = OBJ_TYPE_APPCTX;
appctx->applet = applet; appctx->applet = applet;
@ -93,7 +93,7 @@ static inline void __appctx_free(struct appctx *appctx)
HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock); HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
} }
pool_free2(pool2_connection, appctx); pool_free(pool_head_connection, appctx);
HA_ATOMIC_SUB(&nb_applets, 1); HA_ATOMIC_SUB(&nb_applets, 1);
} }
static inline void appctx_free(struct appctx *appctx) static inline void appctx_free(struct appctx *appctx)

16
include/proto/connection.h
View File

@ -30,8 +30,8 @@
#include <proto/fd.h> #include <proto/fd.h>
#include <proto/obj_type.h> #include <proto/obj_type.h>
extern struct pool_head *pool2_connection; extern struct pool_head *pool_head_connection;
extern struct pool_head *pool2_connstream; extern struct pool_head *pool_head_connstream;
extern struct xprt_ops *registered_xprt[XPRT_ENTRIES]; extern struct xprt_ops *registered_xprt[XPRT_ENTRIES];
extern struct alpn_mux_list alpn_mux_list; extern struct alpn_mux_list alpn_mux_list;
@ -642,13 +642,13 @@ static inline void conn_clear_xprt_done_cb(struct connection *conn)
/* Tries to allocate a new connection and initialized its main fields. The /* Tries to allocate a new connection and initialized its main fields. The
* connection is returned on success, NULL on failure. The connection must * connection is returned on success, NULL on failure. The connection must
* be released using pool_free2() or conn_free(). * be released using pool_free() or conn_free().
*/ */
static inline struct connection *conn_new() static inline struct connection *conn_new()
{ {
struct connection *conn; struct connection *conn;
conn = pool_alloc2(pool2_connection); conn = pool_alloc(pool_head_connection);
if (likely(conn != NULL)) if (likely(conn != NULL))
conn_init(conn); conn_init(conn);
return conn; return conn;
@ -657,13 +657,13 @@ static inline struct connection *conn_new()
/* Releases a conn_stream previously allocated by cs_new() */ /* Releases a conn_stream previously allocated by cs_new() */
static inline void cs_free(struct conn_stream *cs) static inline void cs_free(struct conn_stream *cs)
{ {
pool_free2(pool2_connstream, cs); pool_free(pool_head_connstream, cs);
} }
/* Tries to allocate a new conn_stream and initialize its main fields. If /* Tries to allocate a new conn_stream and initialize its main fields. If
* <conn> is NULL, then a new connection is allocated on the fly, initialized, * <conn> is NULL, then a new connection is allocated on the fly, initialized,
* and assigned to cs->conn ; this connection will then have to be released * and assigned to cs->conn ; this connection will then have to be released
* using pool_free2() or conn_free(). The conn_stream is initialized and added * using pool_free() or conn_free(). The conn_stream is initialized and added
* to the mux's stream list on success, then returned. On failure, nothing is * to the mux's stream list on success, then returned. On failure, nothing is
* allocated and NULL is returned. * allocated and NULL is returned.
*/ */
@ -671,7 +671,7 @@ static inline struct conn_stream *cs_new(struct connection *conn)
{ {
struct conn_stream *cs; struct conn_stream *cs;
cs = pool_alloc2(pool2_connstream); cs = pool_alloc(pool_head_connstream);
if (!likely(cs)) if (!likely(cs))
return NULL; return NULL;
@ -691,7 +691,7 @@ static inline struct conn_stream *cs_new(struct connection *conn)
/* Releases a connection previously allocated by conn_new() */ /* Releases a connection previously allocated by conn_new() */
static inline void conn_free(struct connection *conn) static inline void conn_free(struct connection *conn)
{ {
pool_free2(pool2_connection, conn); pool_free(pool_head_connection, conn);
} }
/* Release a conn_stream, and kill the connection if it was the last one */ /* Release a conn_stream, and kill the connection if it was the last one */

2
include/proto/filters.h
View File

@ -93,7 +93,7 @@
FLT_STRM_DATA_CB_IMPL_2(strm, chn, call, ##__VA_ARGS__), \ FLT_STRM_DATA_CB_IMPL_2(strm, chn, call, ##__VA_ARGS__), \
FLT_STRM_DATA_CB_IMPL_1(strm, chn, call, ##__VA_ARGS__)) FLT_STRM_DATA_CB_IMPL_1(strm, chn, call, ##__VA_ARGS__))
extern struct pool_head *pool2_filter; extern struct pool_head *pool_head_filter;
void flt_deinit(struct proxy *p); void flt_deinit(struct proxy *p);
int flt_check(struct proxy *p); int flt_check(struct proxy *p);

2
include/proto/hdr_idx.h
View File

@ -25,7 +25,7 @@
#include <common/config.h> #include <common/config.h>
#include <types/hdr_idx.h> #include <types/hdr_idx.h>
extern struct pool_head *pool2_hdr_idx; extern struct pool_head *pool_head_hdr_idx;
/* /*
* Initialize the list pointers. * Initialize the list pointers.

4
include/proto/log.h
View File

@ -34,8 +34,8 @@
#include <types/proxy.h> #include <types/proxy.h>
#include <types/stream.h> #include <types/stream.h>
extern struct pool_head *pool2_requri; extern struct pool_head *pool_head_requri;
extern struct pool_head *pool2_uniqueid; extern struct pool_head *pool_head_uniqueid;
extern char *log_format; extern char *log_format;
extern char default_tcp_log_format[]; extern char default_tcp_log_format[];

2
include/proto/queue.h
View File

@ -34,7 +34,7 @@
#include <proto/backend.h> #include <proto/backend.h>
extern struct pool_head *pool2_pendconn; extern struct pool_head *pool_head_pendconn;
int init_pendconn(); int init_pendconn();
struct pendconn *pendconn_add(struct stream *strm); struct pendconn *pendconn_add(struct stream *strm);

2
include/proto/session.h
View File

@ -32,7 +32,7 @@
#include <proto/stick_table.h> #include <proto/stick_table.h>
extern struct pool_head *pool2_session; extern struct pool_head *pool_head_session;
struct session *session_new(struct proxy *fe, struct listener *li, enum obj_type *origin); struct session *session_new(struct proxy *fe, struct listener *li, enum obj_type *origin);
void session_free(struct session *sess); void session_free(struct session *sess);
int init_session(); int init_session();

2
include/proto/signal.h
View File

@ -20,7 +20,7 @@
extern int signal_queue_len; extern int signal_queue_len;
extern struct signal_descriptor signal_state[]; extern struct signal_descriptor signal_state[];
extern struct pool_head *pool2_sig_handlers; extern struct pool_head *pool_head_sig_handlers;
__decl_hathreads(extern HA_SPINLOCK_T signals_lock); __decl_hathreads(extern HA_SPINLOCK_T signals_lock);

2
include/proto/stream.h
View File

@ -30,7 +30,7 @@
#include <proto/stick_table.h> #include <proto/stick_table.h>
#include <proto/task.h> #include <proto/task.h>
extern struct pool_head *pool2_stream; extern struct pool_head *pool_head_stream;
extern struct list streams; extern struct list streams;
extern struct data_cb sess_conn_cb; extern struct data_cb sess_conn_cb;

16
include/proto/task.h
View File

@ -88,8 +88,8 @@ extern unsigned int tasks_run_queue; /* run queue size */
extern unsigned int tasks_run_queue_cur; extern unsigned int tasks_run_queue_cur;
extern unsigned int nb_tasks_cur; extern unsigned int nb_tasks_cur;
extern unsigned int niced_tasks; /* number of niced tasks in the run queue */ extern unsigned int niced_tasks; /* number of niced tasks in the run queue */
extern struct pool_head *pool2_task; extern struct pool_head *pool_head_task;
extern struct pool_head *pool2_notification; extern struct pool_head *pool_head_notification;
__decl_hathreads(extern HA_SPINLOCK_T rq_lock); /* spin lock related to run queue */ __decl_hathreads(extern HA_SPINLOCK_T rq_lock); /* spin lock related to run queue */
__decl_hathreads(extern HA_SPINLOCK_T wq_lock); /* spin lock related to wait queue */ __decl_hathreads(extern HA_SPINLOCK_T wq_lock); /* spin lock related to wait queue */
@ -218,7 +218,7 @@ static inline struct task *task_init(struct task *t, unsigned long thread_mask)
*/ */
static inline struct task *task_new(unsigned long thread_mask) static inline struct task *task_new(unsigned long thread_mask)
{ {
struct task *t = pool_alloc2(pool2_task); struct task *t = pool_alloc(pool_head_task);
if (t) { if (t) {
HA_ATOMIC_ADD(&nb_tasks, 1); HA_ATOMIC_ADD(&nb_tasks, 1);
task_init(t, thread_mask); task_init(t, thread_mask);
@ -232,9 +232,9 @@ static inline struct task *task_new(unsigned long thread_mask)
*/ */
static inline void task_free(struct task *t) static inline void task_free(struct task *t)
{ {
pool_free2(pool2_task, t); pool_free(pool_head_task, t);
if (unlikely(stopping)) if (unlikely(stopping))
pool_flush2(pool2_task); pool_flush(pool_head_task);
HA_ATOMIC_SUB(&nb_tasks, 1); HA_ATOMIC_SUB(&nb_tasks, 1);
} }
@ -291,7 +291,7 @@ static inline void task_schedule(struct task *task, int when)
*/ */
static inline struct notification *notification_new(struct list *purge, struct list *event, struct task *wakeup) static inline struct notification *notification_new(struct list *purge, struct list *event, struct task *wakeup)
{ {
struct notification *com = pool_alloc2(pool2_notification); struct notification *com = pool_alloc(pool_head_notification);
if (!com) if (!com)
return NULL; return NULL;
LIST_ADDQ(purge, &com->purge_me); LIST_ADDQ(purge, &com->purge_me);
@ -315,7 +315,7 @@ static inline void notification_purge(struct list *purge)
LIST_DEL(&com->purge_me); LIST_DEL(&com->purge_me);
if (!com->task) { if (!com->task) {
HA_SPIN_UNLOCK(NOTIF_LOCK, &com->lock); HA_SPIN_UNLOCK(NOTIF_LOCK, &com->lock);
pool_free2(pool2_notification, com); pool_free(pool_head_notification, com);
continue; continue;
} }
com->task = NULL; com->task = NULL;
@ -337,7 +337,7 @@ static inline void notification_wake(struct list *wake)
LIST_DEL(&com->wake_me); LIST_DEL(&com->wake_me);
if (!com->task) { if (!com->task) {
HA_SPIN_UNLOCK(NOTIF_LOCK, &com->lock); HA_SPIN_UNLOCK(NOTIF_LOCK, &com->lock);
pool_free2(pool2_notification, com); pool_free(pool_head_notification, com);
continue; continue;
} }
task_wakeup(com->task, TASK_WOKEN_MSG); task_wakeup(com->task, TASK_WOKEN_MSG);

2
include/types/capture.h
View File

@ -34,7 +34,7 @@ struct cap_hdr {
struct pool_head *pool; /* pool of pre-allocated memory area of (len+1) bytes */ struct pool_head *pool; /* pool of pre-allocated memory area of (len+1) bytes */
}; };
extern struct pool_head *pool2_capture; extern struct pool_head *pool_head_capture;
#endif /* _TYPES_CAPTURE_H */ #endif /* _TYPES_CAPTURE_H */

2
include/types/proto_http.h
View File

@ -357,7 +357,7 @@ extern struct action_kw_list http_res_keywords;
extern const struct http_method_name http_known_methods[HTTP_METH_OTHER]; extern const struct http_method_name http_known_methods[HTTP_METH_OTHER];
extern struct pool_head *pool2_http_txn; extern struct pool_head *pool_head_http_txn;
#endif /* _TYPES_PROTO_HTTP_H */ #endif /* _TYPES_PROTO_HTTP_H */

18
src/buffer.c
View File

@ -20,7 +20,7 @@
#include <types/global.h> #include <types/global.h>
struct pool_head *pool2_buffer; struct pool_head *pool_head_buffer;
/* These buffers are used to always have a valid pointer to an empty buffer in /* These buffers are used to always have a valid pointer to an empty buffer in
* channels. The first buffer is set once a buffer is empty. The second one is * channels. The first buffer is set once a buffer is empty. The second one is
@ -58,8 +58,8 @@ int init_buffer()
{ {
void *buffer; void *buffer;
pool2_buffer = create_pool("buffer", sizeof (struct buffer) + global.tune.bufsize, MEM_F_SHARED|MEM_F_EXACT); pool_head_buffer = create_pool("buffer", sizeof (struct buffer) + global.tune.bufsize, MEM_F_SHARED|MEM_F_EXACT);
if (!pool2_buffer) if (!pool_head_buffer)
return 0; return 0;
/* The reserved buffer is what we leave behind us. Thus we always need /* The reserved buffer is what we leave behind us. Thus we always need
@ -69,17 +69,17 @@ int init_buffer()
* (2 for current session, one for next session that might be needed to * (2 for current session, one for next session that might be needed to
* release a server connection). * release a server connection).
*/ */
pool2_buffer->minavail = MAX(global.tune.reserved_bufs, 3); pool_head_buffer->minavail = MAX(global.tune.reserved_bufs, 3);
if (global.tune.buf_limit) if (global.tune.buf_limit)
pool2_buffer->limit = global.tune.buf_limit; pool_head_buffer->limit = global.tune.buf_limit;
HA_SPIN_INIT(&buffer_wq_lock); HA_SPIN_INIT(&buffer_wq_lock);
buffer = pool_refill_alloc(pool2_buffer, pool2_buffer->minavail - 1); buffer = pool_refill_alloc(pool_head_buffer, pool_head_buffer->minavail - 1);
if (!buffer) if (!buffer)
return 0; return 0;
pool_free2(pool2_buffer, buffer); pool_free(pool_head_buffer, buffer);
hap_register_per_thread_init(init_buffer_per_thread); hap_register_per_thread_init(init_buffer_per_thread);
hap_register_per_thread_deinit(deinit_buffer_per_thread); hap_register_per_thread_deinit(deinit_buffer_per_thread);
@ -88,7 +88,7 @@ int init_buffer()
void deinit_buffer() void deinit_buffer()
{ {
pool_destroy2(pool2_buffer); pool_destroy(pool_head_buffer);
} }
/* This function writes the string <str> at position <pos> which must be in /* This function writes the string <str> at position <pos> which must be in
@ -261,7 +261,7 @@ void __offer_buffer(void *from, unsigned int threshold)
* allocated, and in any case at least one task per two reserved * allocated, and in any case at least one task per two reserved
* buffers. * buffers.
*/ */
avail = pool2_buffer->allocated - pool2_buffer->used - global.tune.reserved_bufs / 2; avail = pool_head_buffer->allocated - pool_head_buffer->used - global.tune.reserved_bufs / 2;
list_for_each_entry_safe(wait, bak, &buffer_wq, list) { list_for_each_entry_safe(wait, bak, &buffer_wq, list) {
if (avail <= threshold) if (avail <= threshold)

14
src/cache.c
View File

@ -38,7 +38,7 @@
static const char *cache_store_flt_id = "cache store filter"; static const char *cache_store_flt_id = "cache store filter";
static struct pool_head *pool2_cache_st = NULL; static struct pool_head *pool_head_cache_st = NULL;
struct applet http_cache_applet; struct applet http_cache_applet;
@ -125,7 +125,7 @@ cache_store_chn_start_analyze(struct stream *s, struct filter *filter, struct ch
if (filter->ctx == NULL) { if (filter->ctx == NULL) {
struct cache_st *st; struct cache_st *st;
st = pool_alloc_dirty(pool2_cache_st); st = pool_alloc_dirty(pool_head_cache_st);
if (st == NULL) if (st == NULL)
return -1; return -1;
@ -160,7 +160,7 @@ cache_store_chn_end_analyze(struct stream *s, struct filter *filter, struct chan
} }
if (st) { if (st) {
pool_free2(pool2_cache_st, st); pool_free(pool_head_cache_st, st);
filter->ctx = NULL; filter->ctx = NULL;
} }
@ -218,7 +218,7 @@ cache_store_http_forward_data(struct stream *s, struct filter *filter,
shctx_row_dec_hot(shctx, st->first_block); shctx_row_dec_hot(shctx, st->first_block);
object->eb.key = 0; object->eb.key = 0;
shctx_unlock(shctx); shctx_unlock(shctx);
pool_free2(pool2_cache_st, st); pool_free(pool_head_cache_st, st);
} else { } else {
/* Skip remaining headers to fill the cache */ /* Skip remaining headers to fill the cache */
b_adv(msg->chn->buf, st->hdrs_len); b_adv(msg->chn->buf, st->hdrs_len);
@ -271,7 +271,7 @@ cache_store_http_end(struct stream *s, struct filter *filter,
} }
if (st) { if (st) {
pool_free2(pool2_cache_st, st); pool_free(pool_head_cache_st, st);
filter->ctx = NULL; filter->ctx = NULL;
} }
@ -488,7 +488,7 @@ enum act_return http_action_store_cache(struct act_rule *rule, struct proxy *px,
shctx_unlock(shctx); shctx_unlock(shctx);
if (filter->ctx) { if (filter->ctx) {
object->eb.key = 0; object->eb.key = 0;
pool_free2(pool2_cache_st, filter->ctx); pool_free(pool_head_cache_st, filter->ctx);
filter->ctx = NULL; filter->ctx = NULL;
} }
goto out; goto out;
@ -1031,6 +1031,6 @@ static void __cache_init(void)
cli_register_kw(&cli_kws); cli_register_kw(&cli_kws);
http_res_keywords_register(&http_res_actions); http_res_keywords_register(&http_res_actions);
http_req_keywords_register(&http_req_actions); http_req_keywords_register(&http_req_actions);
pool2_cache_st = create_pool("cache_st", sizeof(struct cache_st), MEM_F_SHARED); pool_head_cache_st = create_pool("cache_st", sizeof(struct cache_st), MEM_F_SHARED);
} }

6
src/cfgparse.c
View File

@ -7535,9 +7535,9 @@ int check_config_validity()
if (!global.tune.requri_len) if (!global.tune.requri_len)
global.tune.requri_len = REQURI_LEN; global.tune.requri_len = REQURI_LEN;
pool2_requri = create_pool("requri", global.tune.requri_len , MEM_F_SHARED); pool_head_requri = create_pool("requri", global.tune.requri_len , MEM_F_SHARED);
pool2_capture = create_pool("capture", global.tune.cookie_len, MEM_F_SHARED); pool_head_capture = create_pool("capture", global.tune.cookie_len, MEM_F_SHARED);
/* Post initialisation of the users and groups lists. */ /* Post initialisation of the users and groups lists. */
err_code = userlist_postinit(); err_code = userlist_postinit();
@ -9153,7 +9153,7 @@ out_uri_auth_compat:
curproxy->server_state_file_name = strdup(curproxy->id); curproxy->server_state_file_name = strdup(curproxy->id);
} }
pool2_hdr_idx = create_pool("hdr_idx", pool_head_hdr_idx = create_pool("hdr_idx",
global.tune.max_http_hdr * sizeof(struct hdr_idx_elem), global.tune.max_http_hdr * sizeof(struct hdr_idx_elem),
MEM_F_SHARED); MEM_F_SHARED);

36
src/checks.c
View File

@ -70,8 +70,8 @@ static int tcpcheck_get_step_id(struct check *);
static char * tcpcheck_get_step_comment(struct check *, int); static char * tcpcheck_get_step_comment(struct check *, int);
static int tcpcheck_main(struct check *); static int tcpcheck_main(struct check *);
static struct pool_head *pool2_email_alert = NULL; static struct pool_head *pool_head_email_alert = NULL;
static struct pool_head *pool2_tcpcheck_rule = NULL; static struct pool_head *pool_head_tcpcheck_rule = NULL;
static const struct check_status check_statuses[HCHK_STATUS_SIZE] = { static const struct check_status check_statuses[HCHK_STATUS_SIZE] = {
@ -1612,7 +1612,7 @@ static int connect_conn_chk(struct task *t)
} }
static struct list pid_list = LIST_HEAD_INIT(pid_list); static struct list pid_list = LIST_HEAD_INIT(pid_list);
static struct pool_head *pool2_pid_list; static struct pool_head *pool_head_pid_list;
__decl_hathreads(HA_SPINLOCK_T pid_list_lock); __decl_hathreads(HA_SPINLOCK_T pid_list_lock);
void block_sigchld(void) void block_sigchld(void)
@ -1636,7 +1636,7 @@ static struct pid_list *pid_list_add(pid_t pid, struct task *t)
struct pid_list *elem; struct pid_list *elem;
struct check *check = t->context; struct check *check = t->context;
elem = pool_alloc2(pool2_pid_list); elem = pool_alloc(pool_head_pid_list);
if (!elem) if (!elem)
return NULL; return NULL;
elem->pid = pid; elem->pid = pid;
@ -1668,7 +1668,7 @@ static void pid_list_del(struct pid_list *elem)
check = elem->t->context; check = elem->t->context;
check->curpid = NULL; check->curpid = NULL;
pool_free2(pool2_pid_list, elem); pool_free(pool_head_pid_list, elem);
} }
/* Called from inside SIGCHLD handler, SIGCHLD is blocked */ /* Called from inside SIGCHLD handler, SIGCHLD is blocked */
@ -1700,7 +1700,7 @@ static void sigchld_handler(struct sig_handler *sh)
static int init_pid_list(void) static int init_pid_list(void)
{ {
if (pool2_pid_list != NULL) if (pool_head_pid_list != NULL)
/* Nothing to do */ /* Nothing to do */
return 0; return 0;
@ -1710,8 +1710,8 @@ static int init_pid_list(void)
return 1; return 1;
} }
pool2_pid_list = create_pool("pid_list", sizeof(struct pid_list), MEM_F_SHARED); pool_head_pid_list = create_pool("pid_list", sizeof(struct pid_list), MEM_F_SHARED);
if (pool2_pid_list == NULL) { if (pool_head_pid_list == NULL) {
ha_alert("Failed to allocate memory pool for external health checks: %s. Aborting.\n", ha_alert("Failed to allocate memory pool for external health checks: %s. Aborting.\n",
strerror(errno)); strerror(errno));
return 1; return 1;
@ -3122,9 +3122,9 @@ void email_alert_free(struct email_alert *alert)
free(rule->string); free(rule->string);
if (rule->expect_regex) if (rule->expect_regex)
regex_free(rule->expect_regex); regex_free(rule->expect_regex);
pool_free2(pool2_tcpcheck_rule, rule); pool_free(pool_head_tcpcheck_rule, rule);
} }
pool_free2(pool2_email_alert, alert); pool_free(pool_head_email_alert, alert);
} }
static struct task *process_email_alert(struct task *t) static struct task *process_email_alert(struct task *t)
@ -3250,7 +3250,7 @@ static int add_tcpcheck_expect_str(struct list *list, const char *str)
{ {
struct tcpcheck_rule *tcpcheck; struct tcpcheck_rule *tcpcheck;
if ((tcpcheck = pool_alloc2(pool2_tcpcheck_rule)) == NULL) if ((tcpcheck = pool_alloc(pool_head_tcpcheck_rule)) == NULL)
return 0; return 0;
memset(tcpcheck, 0, sizeof(*tcpcheck)); memset(tcpcheck, 0, sizeof(*tcpcheck));
tcpcheck->action = TCPCHK_ACT_EXPECT; tcpcheck->action = TCPCHK_ACT_EXPECT;
@ -3258,7 +3258,7 @@ static int add_tcpcheck_expect_str(struct list *list, const char *str)
tcpcheck->expect_regex = NULL; tcpcheck->expect_regex = NULL;
tcpcheck->comment = NULL; tcpcheck->comment = NULL;
if (!tcpcheck->string) { if (!tcpcheck->string) {
pool_free2(pool2_tcpcheck_rule, tcpcheck); pool_free(pool_head_tcpcheck_rule, tcpcheck);
return 0; return 0;
} }
@ -3273,7 +3273,7 @@ static int add_tcpcheck_send_strs(struct list *list, const char * const *strs)
char *dst; char *dst;
int i; int i;
if ((tcpcheck = pool_alloc2(pool2_tcpcheck_rule)) == NULL) if ((tcpcheck = pool_alloc(pool_head_tcpcheck_rule)) == NULL)
return 0; return 0;
memset(tcpcheck, 0, sizeof(*tcpcheck)); memset(tcpcheck, 0, sizeof(*tcpcheck));
tcpcheck->action = TCPCHK_ACT_SEND; tcpcheck->action = TCPCHK_ACT_SEND;
@ -3285,7 +3285,7 @@ static int add_tcpcheck_send_strs(struct list *list, const char * const *strs)
tcpcheck->string = malloc(tcpcheck->string_len + 1); tcpcheck->string = malloc(tcpcheck->string_len + 1);
if (!tcpcheck->string) { if (!tcpcheck->string) {
pool_free2(pool2_tcpcheck_rule, tcpcheck); pool_free(pool_head_tcpcheck_rule, tcpcheck);
return 0; return 0;
} }
@ -3305,13 +3305,13 @@ static int enqueue_one_email_alert(struct proxy *p, struct server *s,
struct tcpcheck_rule *tcpcheck; struct tcpcheck_rule *tcpcheck;
struct check *check = &q->check; struct check *check = &q->check;
if ((alert = pool_alloc2(pool2_email_alert)) == NULL) if ((alert = pool_alloc(pool_head_email_alert)) == NULL)
goto error; goto error;
LIST_INIT(&alert->list); LIST_INIT(&alert->list);
LIST_INIT(&alert->tcpcheck_rules); LIST_INIT(&alert->tcpcheck_rules);
alert->srv = s; alert->srv = s;
if ((tcpcheck = pool_alloc2(pool2_tcpcheck_rule)) == NULL) if ((tcpcheck = pool_alloc(pool_head_tcpcheck_rule)) == NULL)
goto error; goto error;
memset(tcpcheck, 0, sizeof(*tcpcheck)); memset(tcpcheck, 0, sizeof(*tcpcheck));
tcpcheck->action = TCPCHK_ACT_CONNECT; tcpcheck->action = TCPCHK_ACT_CONNECT;
@ -3499,8 +3499,8 @@ static void __check_init(void)
{ {
hap_register_post_check(start_checks); hap_register_post_check(start_checks);
pool2_email_alert = create_pool("email_alert", sizeof(struct email_alert), MEM_F_SHARED); pool_head_email_alert = create_pool("email_alert", sizeof(struct email_alert), MEM_F_SHARED);
pool2_tcpcheck_rule = create_pool("tcpcheck_rule", sizeof(struct tcpcheck_rule), MEM_F_SHARED); pool_head_tcpcheck_rule = create_pool("tcpcheck_rule", sizeof(struct tcpcheck_rule), MEM_F_SHARED);
} }

14
src/chunk.c
View File

@ -32,7 +32,7 @@ static THREAD_LOCAL char *trash_buf1;
static THREAD_LOCAL char *trash_buf2; static THREAD_LOCAL char *trash_buf2;
/* the trash pool for reentrant allocations */ /* the trash pool for reentrant allocations */
struct pool_head *pool2_trash = NULL; struct pool_head *pool_head_trash = NULL;
/* this is used to drain data, and as a temporary buffer for sprintf()... */ /* this is used to drain data, and as a temporary buffer for sprintf()... */
THREAD_LOCAL struct chunk trash = { .str = NULL }; THREAD_LOCAL struct chunk trash = { .str = NULL };
@ -96,9 +96,9 @@ int init_trash_buffers(int first)
hap_register_per_thread_init(init_trash_buffers_per_thread); hap_register_per_thread_init(init_trash_buffers_per_thread);
hap_register_per_thread_deinit(deinit_trash_buffers_per_thread); hap_register_per_thread_deinit(deinit_trash_buffers_per_thread);
} }
pool_destroy2(pool2_trash); pool_destroy(pool_head_trash);
pool2_trash = create_pool("trash", sizeof(struct chunk) + global.tune.bufsize, MEM_F_EXACT); pool_head_trash = create_pool("trash", sizeof(struct chunk) + global.tune.bufsize, MEM_F_EXACT);
if (!pool2_trash || !alloc_trash_buffers(global.tune.bufsize)) if (!pool_head_trash || !alloc_trash_buffers(global.tune.bufsize))
return 0; return 0;
return 1; return 1;
} }
@ -108,7 +108,7 @@ int init_trash_buffers(int first)
*/ */
void deinit_trash_buffers(void) void deinit_trash_buffers(void)
{ {
pool_destroy2(pool2_trash); pool_destroy(pool_head_trash);
} }
/* /*
@ -121,11 +121,11 @@ struct chunk *alloc_trash_chunk(void)
{ {
struct chunk *chunk; struct chunk *chunk;
chunk = pool_alloc2(pool2_trash); chunk = pool_alloc(pool_head_trash);
if (chunk) { if (chunk) {
char *buf = (char *)chunk + sizeof(struct chunk); char *buf = (char *)chunk + sizeof(struct chunk);
*buf = 0; *buf = 0;
chunk_init(chunk, buf, pool2_trash->size - sizeof(struct chunk)); chunk_init(chunk, buf, pool_head_trash->size - sizeof(struct chunk));
} }
return chunk; return chunk;
} }

16
src/compression.c
View File

@ -166,7 +166,7 @@ static inline int init_comp_ctx(struct comp_ctx **comp_ctx)
HA_SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock); HA_SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock);
} }
*comp_ctx = pool_alloc2(pool_comp_ctx); *comp_ctx = pool_alloc(pool_comp_ctx);
if (*comp_ctx == NULL) if (*comp_ctx == NULL)
return -1; return -1;
#if defined(USE_SLZ) #if defined(USE_SLZ)
@ -192,7 +192,7 @@ static inline int deinit_comp_ctx(struct comp_ctx **comp_ctx)
if (!*comp_ctx) if (!*comp_ctx)
return 0; return 0;
pool_free2(pool_comp_ctx, *comp_ctx); pool_free(pool_comp_ctx, *comp_ctx);
*comp_ctx = NULL; *comp_ctx = NULL;
#ifdef USE_ZLIB #ifdef USE_ZLIB
@ -418,7 +418,7 @@ static void *alloc_zlib(void *opaque, unsigned int items, unsigned int size)
HA_SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock); HA_SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock);
} }
pool = zlib_pool_deflate_state; pool = zlib_pool_deflate_state;
ctx->zlib_deflate_state = buf = pool_alloc2(pool); ctx->zlib_deflate_state = buf = pool_alloc(pool);
break; break;
case 1: case 1:
@ -429,7 +429,7 @@ static void *alloc_zlib(void *opaque, unsigned int items, unsigned int size)
HA_SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock); HA_SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock);
} }
pool = zlib_pool_window; pool = zlib_pool_window;
ctx->zlib_window = buf = pool_alloc2(pool); ctx->zlib_window = buf = pool_alloc(pool);
break; break;
case 2: case 2:
@ -440,7 +440,7 @@ static void *alloc_zlib(void *opaque, unsigned int items, unsigned int size)
HA_SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock); HA_SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock);
} }
pool = zlib_pool_prev; pool = zlib_pool_prev;
ctx->zlib_prev = buf = pool_alloc2(pool); ctx->zlib_prev = buf = pool_alloc(pool);
break; break;
case 3: case 3:
@ -451,7 +451,7 @@ static void *alloc_zlib(void *opaque, unsigned int items, unsigned int size)
HA_SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock); HA_SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock);
} }
pool = zlib_pool_head; pool = zlib_pool_head;
ctx->zlib_head = buf = pool_alloc2(pool); ctx->zlib_head = buf = pool_alloc(pool);
break; break;
case 4: case 4:
@ -462,7 +462,7 @@ static void *alloc_zlib(void *opaque, unsigned int items, unsigned int size)
HA_SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock); HA_SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock);
} }
pool = zlib_pool_pending_buf; pool = zlib_pool_pending_buf;
ctx->zlib_pending_buf = buf = pool_alloc2(pool); ctx->zlib_pending_buf = buf = pool_alloc(pool);
break; break;
} }
if (buf != NULL) if (buf != NULL)
@ -496,7 +496,7 @@ static void free_zlib(void *opaque, void *ptr)
else if (ptr == ctx->zlib_pending_buf) else if (ptr == ctx->zlib_pending_buf)
pool = zlib_pool_pending_buf; pool = zlib_pool_pending_buf;
pool_free2(pool, ptr); pool_free(pool, ptr);
HA_ATOMIC_SUB(&zlib_used_memory, pool->size); HA_ATOMIC_SUB(&zlib_used_memory, pool->size);
} }

16
src/connection.c
View File

@ -27,8 +27,8 @@
#include <proto/ssl_sock.h> #include <proto/ssl_sock.h>
#endif #endif
struct pool_head *pool2_connection; struct pool_head *pool_head_connection;
struct pool_head *pool2_connstream; struct pool_head *pool_head_connstream;
struct xprt_ops *registered_xprt[XPRT_ENTRIES] = { NULL, }; struct xprt_ops *registered_xprt[XPRT_ENTRIES] = { NULL, };
/* List head of all known muxes for ALPN */ /* List head of all known muxes for ALPN */
@ -39,18 +39,18 @@ struct alpn_mux_list alpn_mux_list = {
/* perform minimal intializations, report 0 in case of error, 1 if OK. */ /* perform minimal intializations, report 0 in case of error, 1 if OK. */
int init_connection() int init_connection()
{ {
pool2_connection = create_pool("connection", sizeof (struct connection), MEM_F_SHARED); pool_head_connection = create_pool("connection", sizeof (struct connection), MEM_F_SHARED);
if (!pool2_connection) if (!pool_head_connection)
goto fail_conn; goto fail_conn;
pool2_connstream = create_pool("conn_stream", sizeof(struct conn_stream), MEM_F_SHARED); pool_head_connstream = create_pool("conn_stream", sizeof(struct conn_stream), MEM_F_SHARED);
if (!pool2_connstream) if (!pool_head_connstream)
goto fail_cs; goto fail_cs;
return 1; return 1;
fail_cs: fail_cs:
pool_destroy2(pool2_connection); pool_destroy(pool_head_connection);
pool2_connection = NULL; pool_head_connection = NULL;
fail_conn: fail_conn:
return 0; return 0;
} }

40
src/dns.c
View File

@ -504,7 +504,7 @@ static void dns_check_dns_response(struct dns_resolution *res)
rm_obselete_item: rm_obselete_item:
LIST_DEL(&item->list); LIST_DEL(&item->list);
pool_free2(dns_answer_item_pool, item); pool_free(dns_answer_item_pool, item);
continue; continue;
} }
@ -713,7 +713,7 @@ static int dns_validate_dns_response(unsigned char *resp, unsigned char *bufend,
if (reader >= bufend) if (reader >= bufend)
return DNS_RESP_INVALID; return DNS_RESP_INVALID;
dns_answer_record = pool_alloc2(dns_answer_item_pool); dns_answer_record = pool_alloc(dns_answer_item_pool);
if (dns_answer_record == NULL) if (dns_answer_record == NULL)
return (DNS_RESP_INVALID); return (DNS_RESP_INVALID);
@ -721,14 +721,14 @@ static int dns_validate_dns_response(unsigned char *resp, unsigned char *bufend,
len = dns_read_name(resp, bufend, reader, tmpname, DNS_MAX_NAME_SIZE, &offset); len = dns_read_name(resp, bufend, reader, tmpname, DNS_MAX_NAME_SIZE, &offset);
if (len == 0) { if (len == 0) {
pool_free2(dns_answer_item_pool, dns_answer_record); pool_free(dns_answer_item_pool, dns_answer_record);
return DNS_RESP_INVALID; return DNS_RESP_INVALID;
} }
/* Check if the current record dname is valid. previous_dname /* Check if the current record dname is valid. previous_dname
* points either to queried dname or last CNAME target */ * points either to queried dname or last CNAME target */
if (dns_query->type != DNS_RTYPE_SRV && memcmp(previous_dname, tmpname, len) != 0) { if (dns_query->type != DNS_RTYPE_SRV && memcmp(previous_dname, tmpname, len) != 0) {
pool_free2(dns_answer_item_pool, dns_answer_record); pool_free(dns_answer_item_pool, dns_answer_record);
if (i == 0) { if (i == 0) {
/* First record, means a mismatch issue between /* First record, means a mismatch issue between
* queried dname and dname found in the first * queried dname and dname found in the first
@ -748,13 +748,13 @@ static int dns_validate_dns_response(unsigned char *resp, unsigned char *bufend,
reader += offset; reader += offset;
if (reader >= bufend) { if (reader >= bufend) {
pool_free2(dns_answer_item_pool, dns_answer_record); pool_free(dns_answer_item_pool, dns_answer_record);
return DNS_RESP_INVALID; return DNS_RESP_INVALID;
} }
/* 2 bytes for record type (A, AAAA, CNAME, etc...) */ /* 2 bytes for record type (A, AAAA, CNAME, etc...) */
if (reader + 2 > bufend) { if (reader + 2 > bufend) {
pool_free2(dns_answer_item_pool, dns_answer_record); pool_free(dns_answer_item_pool, dns_answer_record);
return DNS_RESP_INVALID; return DNS_RESP_INVALID;
} }
dns_answer_record->type = reader[0] * 256 + reader[1]; dns_answer_record->type = reader[0] * 256 + reader[1];
@ -762,7 +762,7 @@ static int dns_validate_dns_response(unsigned char *resp, unsigned char *bufend,
/* 2 bytes for class (2) */ /* 2 bytes for class (2) */
if (reader + 2 > bufend) { if (reader + 2 > bufend) {
pool_free2(dns_answer_item_pool, dns_answer_record); pool_free(dns_answer_item_pool, dns_answer_record);
return DNS_RESP_INVALID; return DNS_RESP_INVALID;
} }
dns_answer_record->class = reader[0] * 256 + reader[1]; dns_answer_record->class = reader[0] * 256 + reader[1];
@ -770,7 +770,7 @@ static int dns_validate_dns_response(unsigned char *resp, unsigned char *bufend,
/* 4 bytes for ttl (4) */ /* 4 bytes for ttl (4) */
if (reader + 4 > bufend) { if (reader + 4 > bufend) {
pool_free2(dns_answer_item_pool, dns_answer_record); pool_free(dns_answer_item_pool, dns_answer_record);
return DNS_RESP_INVALID; return DNS_RESP_INVALID;
} }
dns_answer_record->ttl = reader[0] * 16777216 + reader[1] * 65536 dns_answer_record->ttl = reader[0] * 16777216 + reader[1] * 65536
@ -779,7 +779,7 @@ static int dns_validate_dns_response(unsigned char *resp, unsigned char *bufend,
/* Now reading data len */ /* Now reading data len */
if (reader + 2 > bufend) { if (reader + 2 > bufend) {
pool_free2(dns_answer_item_pool, dns_answer_record); pool_free(dns_answer_item_pool, dns_answer_record);
return DNS_RESP_INVALID; return DNS_RESP_INVALID;
} }
dns_answer_record->data_len = reader[0] * 256 + reader[1]; dns_answer_record->data_len = reader[0] * 256 + reader[1];
@ -792,7 +792,7 @@ static int dns_validate_dns_response(unsigned char *resp, unsigned char *bufend,
case DNS_RTYPE_A: case DNS_RTYPE_A:
/* ipv4 is stored on 4 bytes */ /* ipv4 is stored on 4 bytes */
if (dns_answer_record->data_len != 4) { if (dns_answer_record->data_len != 4) {
pool_free2(dns_answer_item_pool, dns_answer_record); pool_free(dns_answer_item_pool, dns_answer_record);
return DNS_RESP_INVALID; return DNS_RESP_INVALID;
} }
dns_answer_record->address.sa_family = AF_INET; dns_answer_record->address.sa_family = AF_INET;
@ -810,14 +810,14 @@ static int dns_validate_dns_response(unsigned char *resp, unsigned char *bufend,
* starts at 1. * starts at 1.
*/ */
if (i + 1 == dns_p->header.ancount) { if (i + 1 == dns_p->header.ancount) {
pool_free2(dns_answer_item_pool, dns_answer_record); pool_free(dns_answer_item_pool, dns_answer_record);
return DNS_RESP_CNAME_ERROR; return DNS_RESP_CNAME_ERROR;
} }
offset = 0; offset = 0;
len = dns_read_name(resp, bufend, reader, tmpname, DNS_MAX_NAME_SIZE, &offset); len = dns_read_name(resp, bufend, reader, tmpname, DNS_MAX_NAME_SIZE, &offset);
if (len == 0) { if (len == 0) {
pool_free2(dns_answer_item_pool, dns_answer_record); pool_free(dns_answer_item_pool, dns_answer_record);
return DNS_RESP_INVALID; return DNS_RESP_INVALID;
} }
@ -835,7 +835,7 @@ static int dns_validate_dns_response(unsigned char *resp, unsigned char *bufend,
* - the target hostname * - the target hostname
*/ */
if (dns_answer_record->data_len <= 6) { if (dns_answer_record->data_len <= 6) {
pool_free2(dns_answer_item_pool, dns_answer_record); pool_free(dns_answer_item_pool, dns_answer_record);
return DNS_RESP_INVALID; return DNS_RESP_INVALID;
} }
dns_answer_record->priority = read_n16(reader); dns_answer_record->priority = read_n16(reader);
@ -847,7 +847,7 @@ static int dns_validate_dns_response(unsigned char *resp, unsigned char *bufend,
offset = 0; offset = 0;
len = dns_read_name(resp, bufend, reader, tmpname, DNS_MAX_NAME_SIZE, &offset); len = dns_read_name(resp, bufend, reader, tmpname, DNS_MAX_NAME_SIZE, &offset);
if (len == 0) { if (len == 0) {
pool_free2(dns_answer_item_pool, dns_answer_record); pool_free(dns_answer_item_pool, dns_answer_record);
return DNS_RESP_INVALID; return DNS_RESP_INVALID;
} }
dns_answer_record->data_len = len; dns_answer_record->data_len = len;
@ -858,7 +858,7 @@ static int dns_validate_dns_response(unsigned char *resp, unsigned char *bufend,
case DNS_RTYPE_AAAA: case DNS_RTYPE_AAAA:
/* ipv6 is stored on 16 bytes */ /* ipv6 is stored on 16 bytes */
if (dns_answer_record->data_len != 16) { if (dns_answer_record->data_len != 16) {
pool_free2(dns_answer_item_pool, dns_answer_record); pool_free(dns_answer_item_pool, dns_answer_record);
return DNS_RESP_INVALID; return DNS_RESP_INVALID;
} }
dns_answer_record->address.sa_family = AF_INET6; dns_answer_record->address.sa_family = AF_INET6;
@ -918,7 +918,7 @@ static int dns_validate_dns_response(unsigned char *resp, unsigned char *bufend,
if (found == 1) { if (found == 1) {
tmp_record->last_seen = now.tv_sec; tmp_record->last_seen = now.tv_sec;
pool_free2(dns_answer_item_pool, dns_answer_record); pool_free(dns_answer_item_pool, dns_answer_record);
} }
else { else {
dns_answer_record->last_seen = now.tv_sec; dns_answer_record->last_seen = now.tv_sec;
@ -1262,7 +1262,7 @@ static struct dns_resolution *dns_pick_resolution(struct dns_resolvers *resolver
from_pool: from_pool:
/* No resolution could be found, so let's allocate a new one */ /* No resolution could be found, so let's allocate a new one */
res = pool_alloc2(dns_resolution_pool); res = pool_alloc(dns_resolution_pool);
if (res) { if (res) {
memset(res, 0, sizeof(*res)); memset(res, 0, sizeof(*res));
res->resolvers = resolvers; res->resolvers = resolvers;
@ -1303,7 +1303,7 @@ static void dns_free_resolution(struct dns_resolution *resolution)
} }
LIST_DEL(&resolution->list); LIST_DEL(&resolution->list);
pool_free2(dns_resolution_pool, resolution); pool_free(dns_resolution_pool, resolution);
} }
/* Links a requester (a server or a dns_srvrq) with a resolution. It returns 0 /* Links a requester (a server or a dns_srvrq) with a resolution. It returns 0
@ -1826,8 +1826,8 @@ static void dns_deinit(void)
free(srvrq); free(srvrq);
} }
pool_destroy2(dns_answer_item_pool); pool_destroy(dns_answer_item_pool);
pool_destroy2(dns_resolution_pool); pool_destroy(dns_resolution_pool);
} }
/* Finalizes the DNS configuration by allocating required resources and checking /* Finalizes the DNS configuration by allocating required resources and checking

12
src/filters.c
View File

@ -31,7 +31,7 @@
#include <proto/stream_interface.h> #include <proto/stream_interface.h>
/* Pool used to allocate filters */ /* Pool used to allocate filters */
struct pool_head *pool2_filter = NULL; struct pool_head *pool_head_filter = NULL;
static int handle_analyzer_result(struct stream *s, struct channel *chn, unsigned int an_bit, int ret); static int handle_analyzer_result(struct stream *s, struct channel *chn, unsigned int an_bit, int ret);
@ -384,7 +384,7 @@ flt_deinit_all_per_thread()
static int static int
flt_stream_add_filter(struct stream *s, struct flt_conf *fconf, unsigned int flags) flt_stream_add_filter(struct stream *s, struct flt_conf *fconf, unsigned int flags)
{ {
struct filter *f = pool_alloc2(pool2_filter); struct filter *f = pool_alloc(pool_head_filter);
if (!f) /* not enough memory */ if (!f) /* not enough memory */
return -1; return -1;
@ -395,7 +395,7 @@ flt_stream_add_filter(struct stream *s, struct flt_conf *fconf, unsigned int fla
if (FLT_OPS(f)->attach) { if (FLT_OPS(f)->attach) {
int ret = FLT_OPS(f)->attach(s, f); int ret = FLT_OPS(f)->attach(s, f);
if (ret <= 0) { if (ret <= 0) {
pool_free2(pool2_filter, f); pool_free(pool_head_filter, f);
return ret; return ret;
} }
} }
@ -439,7 +439,7 @@ flt_stream_release(struct stream *s, int only_backend)
if (FLT_OPS(filter)->detach) if (FLT_OPS(filter)->detach)
FLT_OPS(filter)->detach(s, filter); FLT_OPS(filter)->detach(s, filter);
LIST_DEL(&filter->list); LIST_DEL(&filter->list);
pool_free2(pool2_filter, filter); pool_free(pool_head_filter, filter);
} }
} }
if (LIST_ISEMPTY(&strm_flt(s)->filters)) if (LIST_ISEMPTY(&strm_flt(s)->filters))
@ -1184,7 +1184,7 @@ __attribute__((constructor))
static void static void
__filters_init(void) __filters_init(void)
{ {
pool2_filter = create_pool("filter", sizeof(struct filter), MEM_F_SHARED); pool_head_filter = create_pool("filter", sizeof(struct filter), MEM_F_SHARED);
cfg_register_keywords(&cfg_kws); cfg_register_keywords(&cfg_kws);
hap_register_post_check(flt_init_all); hap_register_post_check(flt_init_all);
hap_register_per_thread_init(flt_init_all_per_thread); hap_register_per_thread_init(flt_init_all_per_thread);
@ -1195,7 +1195,7 @@ __attribute__((destructor))
static void static void
__filters_deinit(void) __filters_deinit(void)
{ {
pool_destroy2(pool2_filter); pool_destroy(pool_head_filter);
} }
/* /*

8
src/flt_http_comp.c
View File

@ -34,7 +34,7 @@ struct flt_ops comp_ops;
/* Pools used to allocate comp_state structs */ /* Pools used to allocate comp_state structs */
static struct pool_head *pool2_comp_state = NULL; static struct pool_head *pool_head_comp_state = NULL;
static THREAD_LOCAL struct buffer *tmpbuf = &buf_empty; static THREAD_LOCAL struct buffer *tmpbuf = &buf_empty;
static THREAD_LOCAL struct buffer *zbuf = &buf_empty; static THREAD_LOCAL struct buffer *zbuf = &buf_empty;
@ -91,7 +91,7 @@ comp_start_analyze(struct stream *s, struct filter *filter, struct channel *chn)
if (filter->ctx == NULL) { if (filter->ctx == NULL) {
struct comp_state *st; struct comp_state *st;
st = pool_alloc_dirty(pool2_comp_state); st = pool_alloc_dirty(pool_head_comp_state);
if (st == NULL) if (st == NULL)
return -1; return -1;
@ -124,7 +124,7 @@ comp_end_analyze(struct stream *s, struct filter *filter, struct channel *chn)
/* release any possible compression context */ /* release any possible compression context */
if (st->comp_algo) if (st->comp_algo)
st->comp_algo->end(&st->comp_ctx); st->comp_algo->end(&st->comp_ctx);
pool_free2(pool2_comp_state, st); pool_free(pool_head_comp_state, st);
filter->ctx = NULL; filter->ctx = NULL;
end: end:
return 1; return 1;
@ -999,5 +999,5 @@ __flt_http_comp_init(void)
cfg_register_keywords(&cfg_kws); cfg_register_keywords(&cfg_kws);
flt_register_keywords(&filter_kws); flt_register_keywords(&filter_kws);
sample_register_fetches(&sample_fetch_keywords); sample_register_fetches(&sample_fetch_keywords);
pool2_comp_state = create_pool("comp_state", sizeof(struct comp_state), MEM_F_SHARED); pool_head_comp_state = create_pool("comp_state", sizeof(struct comp_state), MEM_F_SHARED);
} }

24
src/flt_spoe.c
View File

@ -89,8 +89,8 @@ struct list curmphs;
struct list curgphs; struct list curgphs;
/* Pools used to allocate SPOE structs */ /* Pools used to allocate SPOE structs */
static struct pool_head *pool2_spoe_ctx = NULL; static struct pool_head *pool_head_spoe_ctx = NULL;
static struct pool_head *pool2_spoe_appctx = NULL; static struct pool_head *pool_head_spoe_appctx = NULL;
struct flt_ops spoe_ops; struct flt_ops spoe_ops;
@ -1286,7 +1286,7 @@ spoe_release_appctx(struct appctx *appctx)
/* Release allocated memory */ /* Release allocated memory */
spoe_release_buffer(&spoe_appctx->buffer, spoe_release_buffer(&spoe_appctx->buffer,
&spoe_appctx->buffer_wait); &spoe_appctx->buffer_wait);
pool_free2(pool2_spoe_appctx, spoe_appctx); pool_free(pool_head_spoe_appctx, spoe_appctx);
if (!LIST_ISEMPTY(&agent->rt[tid].applets)) if (!LIST_ISEMPTY(&agent->rt[tid].applets))
goto end; goto end;
@ -1943,10 +1943,10 @@ spoe_create_appctx(struct spoe_config *conf)
if ((appctx = appctx_new(&spoe_applet, tid_bit)) == NULL) if ((appctx = appctx_new(&spoe_applet, tid_bit)) == NULL)
goto out_error; goto out_error;
appctx->ctx.spoe.ptr = pool_alloc_dirty(pool2_spoe_appctx); appctx->ctx.spoe.ptr = pool_alloc_dirty(pool_head_spoe_appctx);
if (SPOE_APPCTX(appctx) == NULL) if (SPOE_APPCTX(appctx) == NULL)
goto out_free_appctx; goto out_free_appctx;
memset(appctx->ctx.spoe.ptr, 0, pool2_spoe_appctx->size); memset(appctx->ctx.spoe.ptr, 0, pool_head_spoe_appctx->size);
appctx->st0 = SPOE_APPCTX_ST_CONNECT; appctx->st0 = SPOE_APPCTX_ST_CONNECT;
if ((SPOE_APPCTX(appctx)->task = task_new(tid_bit)) == NULL) if ((SPOE_APPCTX(appctx)->task = task_new(tid_bit)) == NULL)
@ -2000,7 +2000,7 @@ spoe_create_appctx(struct spoe_config *conf)
out_free_spoe: out_free_spoe:
task_free(SPOE_APPCTX(appctx)->task); task_free(SPOE_APPCTX(appctx)->task);
out_free_spoe_appctx: out_free_spoe_appctx:
pool_free2(pool2_spoe_appctx, SPOE_APPCTX(appctx)); pool_free(pool_head_spoe_appctx, SPOE_APPCTX(appctx));
out_free_appctx: out_free_appctx:
appctx_free(appctx); appctx_free(appctx);
out_error: out_error:
@ -2745,7 +2745,7 @@ spoe_create_context(struct filter *filter)
struct spoe_config *conf = FLT_CONF(filter); struct spoe_config *conf = FLT_CONF(filter);
struct spoe_context *ctx; struct spoe_context *ctx;
ctx = pool_alloc_dirty(pool2_spoe_ctx); ctx = pool_alloc_dirty(pool_head_spoe_ctx);
if (ctx == NULL) { if (ctx == NULL) {
return NULL; return NULL;
} }
@ -2776,7 +2776,7 @@ spoe_destroy_context(struct spoe_context *ctx)
return; return;
spoe_stop_processing(ctx); spoe_stop_processing(ctx);
pool_free2(pool2_spoe_ctx, ctx); pool_free(pool_head_spoe_ctx, ctx);
} }
static void static void
@ -4321,14 +4321,14 @@ static void __spoe_init(void)
http_req_keywords_register(&http_req_action_kws); http_req_keywords_register(&http_req_action_kws);
http_res_keywords_register(&http_res_action_kws); http_res_keywords_register(&http_res_action_kws);
pool2_spoe_ctx = create_pool("spoe_ctx", sizeof(struct spoe_context), MEM_F_SHARED); pool_head_spoe_ctx = create_pool("spoe_ctx", sizeof(struct spoe_context), MEM_F_SHARED);
pool2_spoe_appctx = create_pool("spoe_appctx", sizeof(struct spoe_appctx), MEM_F_SHARED); pool_head_spoe_appctx = create_pool("spoe_appctx", sizeof(struct spoe_appctx), MEM_F_SHARED);
} }
__attribute__((destructor)) __attribute__((destructor))
static void static void
__spoe_deinit(void) __spoe_deinit(void)
{ {
pool_destroy2(pool2_spoe_ctx); pool_destroy(pool_head_spoe_ctx);
pool_destroy2(pool2_spoe_appctx); pool_destroy(pool_head_spoe_appctx);
} }

8
src/frontend.c
View File

@ -131,13 +131,13 @@ int frontend_accept(struct stream *s)
s->req.flags |= CF_READ_DONTWAIT; /* one read is usually enough */ s->req.flags |= CF_READ_DONTWAIT; /* one read is usually enough */
if (unlikely(fe->nb_req_cap > 0)) { if (unlikely(fe->nb_req_cap > 0)) {
if ((s->req_cap = pool_alloc2(fe->req_cap_pool)) == NULL) if ((s->req_cap = pool_alloc(fe->req_cap_pool)) == NULL)
goto out_return; /* no memory */ goto out_return; /* no memory */
memset(s->req_cap, 0, fe->nb_req_cap * sizeof(void *)); memset(s->req_cap, 0, fe->nb_req_cap * sizeof(void *));
} }
if (unlikely(fe->nb_rsp_cap > 0)) { if (unlikely(fe->nb_rsp_cap > 0)) {
if ((s->res_cap = pool_alloc2(fe->rsp_cap_pool)) == NULL) if ((s->res_cap = pool_alloc(fe->rsp_cap_pool)) == NULL)
goto out_free_reqcap; /* no memory */ goto out_free_reqcap; /* no memory */
memset(s->res_cap, 0, fe->nb_rsp_cap * sizeof(void *)); memset(s->res_cap, 0, fe->nb_rsp_cap * sizeof(void *));
} }
@ -159,9 +159,9 @@ int frontend_accept(struct stream *s)
/* Error unrolling */ /* Error unrolling */
out_free_rspcap: out_free_rspcap:
pool_free2(fe->rsp_cap_pool, s->res_cap); pool_free(fe->rsp_cap_pool, s->res_cap);
out_free_reqcap: out_free_reqcap:
pool_free2(fe->req_cap_pool, s->req_cap); pool_free(fe->req_cap_pool, s->req_cap);
out_return: out_return:
return -1; return -1;
} }

38
src/haproxy.c
View File

@ -796,7 +796,7 @@ static void sig_soft_stop(struct sig_handler *sh)
{ {
soft_stop(); soft_stop();
signal_unregister_handler(sh); signal_unregister_handler(sh);
pool_gc2(NULL); pool_gc(NULL);
} }
/* /*
@ -805,7 +805,7 @@ static void sig_soft_stop(struct sig_handler *sh)
static void sig_pause(struct sig_handler *sh) static void sig_pause(struct sig_handler *sh)
{ {
pause_proxies(); pause_proxies();
pool_gc2(NULL); pool_gc(NULL);
} }
/* /*
@ -869,7 +869,7 @@ static void dump(struct sig_handler *sh)
{ {
/* dump memory usage then free everything possible */ /* dump memory usage then free everything possible */
dump_pools(); dump_pools();
pool_gc2(NULL); pool_gc(NULL);
} }
/* This function check if cfg_cfgfiles containes directories. /* This function check if cfg_cfgfiles containes directories.
@ -2094,7 +2094,7 @@ void deinit(void)
while (h) { while (h) {
h_next = h->next; h_next = h->next;
free(h->name); free(h->name);
pool_destroy2(h->pool); pool_destroy(h->pool);
free(h); free(h);
h = h_next; h = h_next;
}/* end while(h) */ }/* end while(h) */
@ -2103,7 +2103,7 @@ void deinit(void)
while (h) { while (h) {
h_next = h->next; h_next = h->next;
free(h->name); free(h->name);
pool_destroy2(h->pool); pool_destroy(h->pool);
free(h); free(h);
h = h_next; h = h_next;
}/* end while(h) */ }/* end while(h) */
@ -2183,9 +2183,9 @@ void deinit(void)
free_http_res_rules(&p->http_res_rules); free_http_res_rules(&p->http_res_rules);
task_free(p->task); task_free(p->task);
pool_destroy2(p->req_cap_pool); pool_destroy(p->req_cap_pool);
pool_destroy2(p->rsp_cap_pool); pool_destroy(p->rsp_cap_pool);
pool_destroy2(p->table.pool); pool_destroy(p->table.pool);
p0 = p; p0 = p;
p = p->next; p = p->next;
@ -2251,17 +2251,17 @@ void deinit(void)
deinit_buffer(); deinit_buffer();
pool_destroy2(pool2_stream); pool_destroy(pool_head_stream);
pool_destroy2(pool2_session); pool_destroy(pool_head_session);
pool_destroy2(pool2_connection); pool_destroy(pool_head_connection);
pool_destroy2(pool2_connstream); pool_destroy(pool_head_connstream);
pool_destroy2(pool2_requri); pool_destroy(pool_head_requri);
pool_destroy2(pool2_task); pool_destroy(pool_head_task);
pool_destroy2(pool2_capture); pool_destroy(pool_head_capture);
pool_destroy2(pool2_pendconn); pool_destroy(pool_head_pendconn);
pool_destroy2(pool2_sig_handlers); pool_destroy(pool_head_sig_handlers);
pool_destroy2(pool2_hdr_idx); pool_destroy(pool_head_hdr_idx);
pool_destroy2(pool2_http_txn); pool_destroy(pool_head_http_txn);
deinit_pollers(); deinit_pollers();
} /* end deinit() */ } /* end deinit() */

2
src/hdr_idx.c
View File

@ -14,7 +14,7 @@
#include <common/memory.h> #include <common/memory.h>
#include <proto/hdr_idx.h> #include <proto/hdr_idx.h>
struct pool_head *pool2_hdr_idx = NULL; struct pool_head *pool_head_hdr_idx = NULL;
/* /*
* Add a header entry to <list> after element <after>. <after> is ignored when * Add a header entry to <list> after element <after>. <after> is ignored when

22
src/hlua.c
View File

@ -160,7 +160,7 @@ struct hlua gL;
/* This is the memory pool containing struct lua for applets /* This is the memory pool containing struct lua for applets
* (including cli). * (including cli).
*/ */
struct pool_head *pool2_hlua; struct pool_head *pool_head_hlua;
/* Used for Socket connection. */ /* Used for Socket connection. */
static struct proxy socket_proxy; static struct proxy socket_proxy;
@ -876,7 +876,7 @@ void hlua_ctx_destroy(struct hlua *lua)
lua->T = NULL; lua->T = NULL;
end: end:
pool_free2(pool2_hlua, lua); pool_free(pool_head_hlua, lua);
} }
/* This function is used to restore the Lua context when a coroutine /* This function is used to restore the Lua context when a coroutine
@ -2498,7 +2498,7 @@ __LJMP static int hlua_socket_new(lua_State *L)
socket->tid = tid; socket->tid = tid;
/* Check if the various memory pools are intialized. */ /* Check if the various memory pools are intialized. */
if (!pool2_stream || !pool2_buffer) { if (!pool_head_stream || !pool_head_buffer) {
hlua_pusherror(L, "socket: uninitialized pools."); hlua_pusherror(L, "socket: uninitialized pools.");
goto out_fail_conf; goto out_fail_conf;
} }
@ -5578,7 +5578,7 @@ static int hlua_register_task(lua_State *L)
ref = MAY_LJMP(hlua_checkfunction(L, 1)); ref = MAY_LJMP(hlua_checkfunction(L, 1));
hlua = pool_alloc2(pool2_hlua); hlua = pool_alloc(pool_head_hlua);
if (!hlua) if (!hlua)
WILL_LJMP(luaL_error(L, "lua out of memory error.")); WILL_LJMP(luaL_error(L, "lua out of memory error."));
@ -5618,7 +5618,7 @@ static int hlua_sample_conv_wrapper(const struct arg *arg_p, struct sample *smp,
* Lua initialization cause 5% performances loss. * Lua initialization cause 5% performances loss.
*/ */
if (!stream->hlua) { if (!stream->hlua) {
stream->hlua = pool_alloc2(pool2_hlua); stream->hlua = pool_alloc(pool_head_hlua);
if (!stream->hlua) { if (!stream->hlua) {
SEND_ERR(stream->be, "Lua converter '%s': can't initialize Lua context.\n", fcn->name); SEND_ERR(stream->be, "Lua converter '%s': can't initialize Lua context.\n", fcn->name);
return 0; return 0;
@ -5738,7 +5738,7 @@ static int hlua_sample_fetch_wrapper(const struct arg *arg_p, struct sample *smp
* Lua initialization cause 5% performances loss. * Lua initialization cause 5% performances loss.
*/ */
if (!stream->hlua) { if (!stream->hlua) {
stream->hlua = pool_alloc2(pool2_hlua); stream->hlua = pool_alloc(pool_head_hlua);
if (!stream->hlua) { if (!stream->hlua) {
SEND_ERR(stream->be, "Lua sample-fetch '%s': can't initialize Lua context.\n", fcn->name); SEND_ERR(stream->be, "Lua sample-fetch '%s': can't initialize Lua context.\n", fcn->name);
return 0; return 0;
@ -5996,7 +5996,7 @@ static enum act_return hlua_action(struct act_rule *rule, struct proxy *px,
* Lua initialization cause 5% performances loss. * Lua initialization cause 5% performances loss.
*/ */
if (!s->hlua) { if (!s->hlua) {
s->hlua = pool_alloc2(pool2_hlua); s->hlua = pool_alloc(pool_head_hlua);
if (!s->hlua) { if (!s->hlua) {
SEND_ERR(px, "Lua action '%s': can't initialize Lua context.\n", SEND_ERR(px, "Lua action '%s': can't initialize Lua context.\n",
rule->arg.hlua_rule->fcn.name); rule->arg.hlua_rule->fcn.name);
@ -6152,7 +6152,7 @@ static int hlua_applet_tcp_init(struct appctx *ctx, struct proxy *px, struct str
char **arg; char **arg;
const char *error; const char *error;
hlua = pool_alloc2(pool2_hlua); hlua = pool_alloc(pool_head_hlua);
if (!hlua) { if (!hlua) {
SEND_ERR(px, "Lua applet tcp '%s': out of memory.\n", SEND_ERR(px, "Lua applet tcp '%s': out of memory.\n",
ctx->rule->arg.hlua_rule->fcn.name); ctx->rule->arg.hlua_rule->fcn.name);
@ -6349,7 +6349,7 @@ static int hlua_applet_http_init(struct appctx *ctx, struct proxy *px, struct st
if ((txn->flags & TX_CON_WANT_MSK) == TX_CON_WANT_KAL) if ((txn->flags & TX_CON_WANT_MSK) == TX_CON_WANT_KAL)
txn->flags = (txn->flags & ~TX_CON_WANT_MSK) | TX_CON_WANT_SCL; txn->flags = (txn->flags & ~TX_CON_WANT_MSK) | TX_CON_WANT_SCL;
hlua = pool_alloc2(pool2_hlua); hlua = pool_alloc(pool_head_hlua);
if (!hlua) { if (!hlua) {
SEND_ERR(px, "Lua applet http '%s': out of memory.\n", SEND_ERR(px, "Lua applet http '%s': out of memory.\n",
ctx->rule->arg.hlua_rule->fcn.name); ctx->rule->arg.hlua_rule->fcn.name);
@ -6897,7 +6897,7 @@ static int hlua_cli_parse_fct(char **args, struct appctx *appctx, void *private)
fcn = private; fcn = private;
appctx->ctx.hlua_cli.fcn = private; appctx->ctx.hlua_cli.fcn = private;
hlua = pool_alloc2(pool2_hlua); hlua = pool_alloc(pool_head_hlua);
if (!hlua) { if (!hlua) {
SEND_ERR(NULL, "Lua cli '%s': out of memory.\n", fcn->name); SEND_ERR(NULL, "Lua cli '%s': out of memory.\n", fcn->name);
return 1; return 1;
@ -7371,7 +7371,7 @@ void hlua_init(void)
HA_SPIN_INIT(&hlua_global_lock); HA_SPIN_INIT(&hlua_global_lock);
/* Initialise struct hlua and com signals pool */ /* Initialise struct hlua and com signals pool */
pool2_hlua = create_pool("hlua", sizeof(struct hlua), MEM_F_SHARED); pool_head_hlua = create_pool("hlua", sizeof(struct hlua), MEM_F_SHARED);
/* Register configuration keywords. */ /* Register configuration keywords. */
cfg_register_keywords(&cfg_kws); cfg_register_keywords(&cfg_kws);

2
src/log.c
View File

@ -2378,7 +2378,7 @@ void strm_log(struct stream *s)
/* if unique-id was not generated */ /* if unique-id was not generated */
if (!s->unique_id && !LIST_ISEMPTY(&sess->fe->format_unique_id)) { if (!s->unique_id && !LIST_ISEMPTY(&sess->fe->format_unique_id)) {
if ((s->unique_id = pool_alloc2(pool2_uniqueid)) != NULL) if ((s->unique_id = pool_alloc(pool_head_uniqueid)) != NULL)
build_logline(s, s->unique_id, UNIQUEID_LEN, &sess->fe->format_unique_id); build_logline(s, s->unique_id, UNIQUEID_LEN, &sess->fe->format_unique_id);
} }

12
src/memory.c
View File

@ -123,7 +123,7 @@ void *__pool_refill_alloc(struct pool_head *pool, unsigned int avail)
if (failed) if (failed)
return NULL; return NULL;
failed++; failed++;
pool_gc2(pool); pool_gc(pool);
continue; continue;
} }
if (++pool->allocated > avail) if (++pool->allocated > avail)
@ -151,7 +151,7 @@ void *pool_refill_alloc(struct pool_head *pool, unsigned int avail)
/* /*
* This function frees whatever can be freed in pool <pool>. * This function frees whatever can be freed in pool <pool>.
*/ */
void pool_flush2(struct pool_head *pool) void pool_flush(struct pool_head *pool)
{ {
void *temp, *next; void *temp, *next;
if (!pool) if (!pool)
@ -175,11 +175,11 @@ void pool_flush2(struct pool_head *pool)
* the minimum thresholds imposed by owners. It takes care of avoiding * the minimum thresholds imposed by owners. It takes care of avoiding
* recursion because it may be called from a signal handler. * recursion because it may be called from a signal handler.
* *
* <pool_ctx> is used when pool_gc2 is called to release resources to allocate * <pool_ctx> is used when pool_gc is called to release resources to allocate
* an element in __pool_refill_alloc. It is important because <pool_ctx> is * an element in __pool_refill_alloc. It is important because <pool_ctx> is
* already locked, so we need to skip the lock here. * already locked, so we need to skip the lock here.
*/ */
void pool_gc2(struct pool_head *pool_ctx) void pool_gc(struct pool_head *pool_ctx)
{ {
static int recurse; static int recurse;
int cur_recurse = 0; int cur_recurse = 0;
@ -216,10 +216,10 @@ void pool_gc2(struct pool_head *pool_ctx)
* pointer, otherwise it returns the pool. * pointer, otherwise it returns the pool.
* . * .
*/ */
void *pool_destroy2(struct pool_head *pool) void *pool_destroy(struct pool_head *pool)
{ {
if (pool) { if (pool) {
pool_flush2(pool); pool_flush(pool);
if (pool->used) if (pool->used)
return pool; return pool;
pool->users--; pool->users--;

30
src/mux_h2.c
View File

@ -30,9 +30,9 @@ static const struct h2s *h2_closed_stream;
static const struct h2s *h2_idle_stream; static const struct h2s *h2_idle_stream;
/* the h2c connection pool */ /* the h2c connection pool */
static struct pool_head *pool2_h2c; static struct pool_head *pool_head_h2c;
/* the h2s stream pool */ /* the h2s stream pool */
static struct pool_head *pool2_h2s; static struct pool_head *pool_head_h2s;
/* Connection flags (32 bit), in h2c->flags */ /* Connection flags (32 bit), in h2c->flags */
#define H2_CF_NONE 0x00000000 #define H2_CF_NONE 0x00000000
@ -328,7 +328,7 @@ static int h2c_frt_init(struct connection *conn)
struct task *t = NULL; struct task *t = NULL;
struct session *sess = conn->owner; struct session *sess = conn->owner;
h2c = pool_alloc2(pool2_h2c); h2c = pool_alloc(pool_head_h2c);
if (!h2c) if (!h2c)
goto fail; goto fail;
@ -387,7 +387,7 @@ static int h2c_frt_init(struct connection *conn)
fail: fail:
if (t) if (t)
task_free(t); task_free(t);
pool_free2(pool2_h2c, h2c); pool_free(pool_head_h2c, h2c);
return -1; return -1;
} }
@ -448,7 +448,7 @@ static void h2_release(struct connection *conn)
h2c->task = NULL; h2c->task = NULL;
} }
pool_free2(pool2_h2c, h2c); pool_free(pool_head_h2c, h2c);
} }
conn->mux = NULL; conn->mux = NULL;
@ -597,7 +597,7 @@ static struct h2s *h2c_stream_new(struct h2c *h2c, int id)
struct conn_stream *cs; struct conn_stream *cs;
struct h2s *h2s; struct h2s *h2s;
h2s = pool_alloc2(pool2_h2s); h2s = pool_alloc(pool_head_h2s);
if (!h2s) if (!h2s)
goto out; goto out;
@ -631,7 +631,7 @@ static struct h2s *h2c_stream_new(struct h2c *h2c, int id)
cs_free(cs); cs_free(cs);
out_close: out_close:
eb32_delete(&h2s->by_id); eb32_delete(&h2s->by_id);
pool_free2(pool2_h2s, h2s); pool_free(pool_head_h2s, h2s);
h2s = NULL; h2s = NULL;
out: out:
return h2s; return h2s;
@ -992,7 +992,7 @@ static void h2_wake_some_streams(struct h2c *h2c, int last, uint32_t flags)
if (!h2s->cs) { if (!h2s->cs) {
/* this stream was already orphaned */ /* this stream was already orphaned */
eb32_delete(&h2s->by_id); eb32_delete(&h2s->by_id);
pool_free2(pool2_h2s, h2s); pool_free(pool_head_h2s, h2s);
continue; continue;
} }
@ -1905,7 +1905,7 @@ static int h2_process_mux(struct h2c *h2c)
else { else {
/* just sent the last frame for this orphaned stream */ /* just sent the last frame for this orphaned stream */
eb32_delete(&h2s->by_id); eb32_delete(&h2s->by_id);
pool_free2(pool2_h2s, h2s); pool_free(pool_head_h2s, h2s);
} }
} }
} }
@ -1947,7 +1947,7 @@ static int h2_process_mux(struct h2c *h2c)
else { else {
/* just sent the last frame for this orphaned stream */ /* just sent the last frame for this orphaned stream */
eb32_delete(&h2s->by_id); eb32_delete(&h2s->by_id);
pool_free2(pool2_h2s, h2s); pool_free(pool_head_h2s, h2s);
} }
} }
} }
@ -2322,7 +2322,7 @@ static void h2_detach(struct conn_stream *cs)
h2c->task->expire = TICK_ETERNITY; h2c->task->expire = TICK_ETERNITY;
} }
} }
pool_free2(pool2_h2s, h2s); pool_free(pool_head_h2s, h2s);
} }
static void h2_shutr(struct conn_stream *cs, enum cs_shr_mode mode) static void h2_shutr(struct conn_stream *cs, enum cs_shr_mode mode)
@ -3202,8 +3202,8 @@ static struct cfg_kw_list cfg_kws = {ILH, {
static void __h2_deinit(void) static void __h2_deinit(void)
{ {
pool_destroy2(pool2_h2s); pool_destroy(pool_head_h2s);
pool_destroy2(pool2_h2c); pool_destroy(pool_head_h2c);
} }
__attribute__((constructor)) __attribute__((constructor))
@ -3212,6 +3212,6 @@ static void __h2_init(void)
alpn_register_mux(&alpn_mux_h2); alpn_register_mux(&alpn_mux_h2);
cfg_register_keywords(&cfg_kws); cfg_register_keywords(&cfg_kws);
hap_register_post_deinit(__h2_deinit); hap_register_post_deinit(__h2_deinit);
pool2_h2c = create_pool("h2c", sizeof(struct h2c), MEM_F_SHARED); pool_head_h2c = create_pool("h2c", sizeof(struct h2c), MEM_F_SHARED);
pool2_h2s = create_pool("h2s", sizeof(struct h2s), MEM_F_SHARED); pool_head_h2s = create_pool("h2s", sizeof(struct h2s), MEM_F_SHARED);
} }

2
src/peers.c
View File

@ -1941,7 +1941,7 @@ static struct appctx *peer_session_create(struct peers *peers, struct peer *peer
conn_free(conn); conn_free(conn);
out_free_strm: out_free_strm:
LIST_DEL(&s->list); LIST_DEL(&s->list);
pool_free2(pool2_stream, s); pool_free(pool_head_stream, s);
out_free_sess: out_free_sess:
session_free(sess); session_free(sess);
out_free_appctx: out_free_appctx:

10
src/pipe.c
View File

@ -20,7 +20,7 @@
#include <types/global.h> #include <types/global.h>
#include <types/pipe.h> #include <types/pipe.h>
struct pool_head *pool2_pipe = NULL; struct pool_head *pool_head_pipe = NULL;
struct pipe *pipes_live = NULL; /* pipes which are still ready to use */ struct pipe *pipes_live = NULL; /* pipes which are still ready to use */
__decl_hathreads(HA_SPINLOCK_T pipes_lock); /* lock used to protect pipes list */ __decl_hathreads(HA_SPINLOCK_T pipes_lock); /* lock used to protect pipes list */
@ -31,7 +31,7 @@ int pipes_free = 0; /* # of pipes unused */
/* allocate memory for the pipes */ /* allocate memory for the pipes */
static void init_pipe() static void init_pipe()
{ {
pool2_pipe = create_pool("pipe", sizeof(struct pipe), MEM_F_SHARED); pool_head_pipe = create_pool("pipe", sizeof(struct pipe), MEM_F_SHARED);
pipes_used = 0; pipes_used = 0;
pipes_free = 0; pipes_free = 0;
HA_SPIN_INIT(&pipes_lock); HA_SPIN_INIT(&pipes_lock);
@ -57,12 +57,12 @@ struct pipe *get_pipe()
if (pipes_used >= global.maxpipes) if (pipes_used >= global.maxpipes)
goto out; goto out;
ret = pool_alloc2(pool2_pipe); ret = pool_alloc(pool_head_pipe);
if (!ret) if (!ret)
goto out; goto out;
if (pipe(pipefd) < 0) { if (pipe(pipefd) < 0) {
pool_free2(pool2_pipe, ret); pool_free(pool_head_pipe, ret);
goto out; goto out;
} }
#ifdef F_SETPIPE_SZ #ifdef F_SETPIPE_SZ
@ -83,7 +83,7 @@ static void inline __kill_pipe(struct pipe *p)
{ {
close(p->prod); close(p->prod);
close(p->cons); close(p->cons);
pool_free2(pool2_pipe, p); pool_free(pool_head_pipe, p);
pipes_used--; pipes_used--;
return; return;
} }

52
src/proto_http.c
View File

@ -470,8 +470,8 @@ void init_proto_http()
FD_SET(0x7f, http_encode_map); FD_SET(0x7f, http_encode_map);
/* memory allocations */ /* memory allocations */
pool2_http_txn = create_pool("http_txn", sizeof(struct http_txn), MEM_F_SHARED); pool_head_http_txn = create_pool("http_txn", sizeof(struct http_txn), MEM_F_SHARED);
pool2_uniqueid = create_pool("uniqueid", UNIQUEID_LEN, MEM_F_SHARED); pool_head_uniqueid = create_pool("uniqueid", UNIQUEID_LEN, MEM_F_SHARED);
} }
/* /*
@ -1188,10 +1188,10 @@ void http_return_srv_error(struct stream *s, struct stream_interface *si)
extern const char sess_term_cond[8]; extern const char sess_term_cond[8];
extern const char sess_fin_state[8]; extern const char sess_fin_state[8];
extern const char *monthname[12]; extern const char *monthname[12];
struct pool_head *pool2_http_txn; struct pool_head *pool_head_http_txn;
struct pool_head *pool2_requri; struct pool_head *pool_head_requri;
struct pool_head *pool2_capture = NULL; struct pool_head *pool_head_capture = NULL;
struct pool_head *pool2_uniqueid; struct pool_head *pool_head_uniqueid;
/* /*
* Capture headers from message starting at <som> according to header list * Capture headers from message starting at <som> according to header list
@ -1224,7 +1224,7 @@ void capture_headers(char *som, struct hdr_idx *idx,
(strncasecmp(sol, h->name, h->namelen) == 0)) { (strncasecmp(sol, h->name, h->namelen) == 0)) {
if (cap[h->index] == NULL) if (cap[h->index] == NULL)
cap[h->index] = cap[h->index] =
pool_alloc2(h->pool); pool_alloc(h->pool);
if (cap[h->index] == NULL) { if (cap[h->index] == NULL) {
ha_alert("HTTP capture : out of memory.\n"); ha_alert("HTTP capture : out of memory.\n");
@ -1958,7 +1958,7 @@ int http_wait_for_request(struct stream *s, struct channel *req, int an_bit)
*/ */
if (unlikely(s->logs.logwait & LW_REQ)) { if (unlikely(s->logs.logwait & LW_REQ)) {
/* we have a complete HTTP request that we must log */ /* we have a complete HTTP request that we must log */
if ((txn->uri = pool_alloc2(pool2_requri)) != NULL) { if ((txn->uri = pool_alloc(pool_head_requri)) != NULL) {
int urilen = msg->sl.rq.l; int urilen = msg->sl.rq.l;
if (urilen >= global.tune.requri_len ) if (urilen >= global.tune.requri_len )
@ -3731,7 +3731,7 @@ int http_process_request(struct stream *s, struct channel *req, int an_bit)
/* add unique-id if "header-unique-id" is specified */ /* add unique-id if "header-unique-id" is specified */
if (!LIST_ISEMPTY(&sess->fe->format_unique_id) && !s->unique_id) { if (!LIST_ISEMPTY(&sess->fe->format_unique_id) && !s->unique_id) {
if ((s->unique_id = pool_alloc2(pool2_uniqueid)) == NULL) if ((s->unique_id = pool_alloc(pool_head_uniqueid)) == NULL)
goto return_bad_req; goto return_bad_req;
s->unique_id[0] = '\0'; s->unique_id[0] = '\0';
build_logline(s, s->unique_id, UNIQUEID_LEN, &sess->fe->format_unique_id); build_logline(s, s->unique_id, UNIQUEID_LEN, &sess->fe->format_unique_id);
@ -6890,7 +6890,7 @@ void manage_client_side_cookies(struct stream *s, struct channel *req)
memcmp(att_beg, sess->fe->capture_name, sess->fe->capture_namelen) == 0) { memcmp(att_beg, sess->fe->capture_name, sess->fe->capture_namelen) == 0) {
int log_len = val_end - att_beg; int log_len = val_end - att_beg;
if ((txn->cli_cookie = pool_alloc2(pool2_capture)) == NULL) { if ((txn->cli_cookie = pool_alloc(pool_head_capture)) == NULL) {
ha_alert("HTTP logging : out of memory.\n"); ha_alert("HTTP logging : out of memory.\n");
} else { } else {
if (log_len > sess->fe->capture_len) if (log_len > sess->fe->capture_len)
@ -7542,7 +7542,7 @@ void manage_server_side_cookies(struct stream *s, struct channel *res)
(val_end - att_beg >= sess->fe->capture_namelen) && (val_end - att_beg >= sess->fe->capture_namelen) &&
memcmp(att_beg, sess->fe->capture_name, sess->fe->capture_namelen) == 0) { memcmp(att_beg, sess->fe->capture_name, sess->fe->capture_namelen) == 0) {
int log_len = val_end - att_beg; int log_len = val_end - att_beg;
if ((txn->srv_cookie = pool_alloc2(pool2_capture)) == NULL) { if ((txn->srv_cookie = pool_alloc(pool_head_capture)) == NULL) {
ha_alert("HTTP logging : out of memory.\n"); ha_alert("HTTP logging : out of memory.\n");
} }
else { else {
@ -7988,14 +7988,14 @@ struct http_txn *http_alloc_txn(struct stream *s)
if (txn) if (txn)
return txn; return txn;
txn = pool_alloc2(pool2_http_txn); txn = pool_alloc(pool_head_http_txn);
if (!txn) if (!txn)
return txn; return txn;
txn->hdr_idx.size = global.tune.max_http_hdr; txn->hdr_idx.size = global.tune.max_http_hdr;
txn->hdr_idx.v = pool_alloc2(pool2_hdr_idx); txn->hdr_idx.v = pool_alloc(pool_head_hdr_idx);
if (!txn->hdr_idx.v) { if (!txn->hdr_idx.v) {
pool_free2(pool2_http_txn, txn); pool_free(pool_head_http_txn, txn);
return NULL; return NULL;
} }
@ -8069,10 +8069,10 @@ void http_end_txn(struct stream *s)
struct proxy *fe = strm_fe(s); struct proxy *fe = strm_fe(s);
/* these ones will have been dynamically allocated */ /* these ones will have been dynamically allocated */
pool_free2(pool2_requri, txn->uri); pool_free(pool_head_requri, txn->uri);
pool_free2(pool2_capture, txn->cli_cookie); pool_free(pool_head_capture, txn->cli_cookie);
pool_free2(pool2_capture, txn->srv_cookie); pool_free(pool_head_capture, txn->srv_cookie);
pool_free2(pool2_uniqueid, s->unique_id); pool_free(pool_head_uniqueid, s->unique_id);
s->unique_id = NULL; s->unique_id = NULL;
txn->uri = NULL; txn->uri = NULL;
@ -8082,14 +8082,14 @@ void http_end_txn(struct stream *s)
if (s->req_cap) { if (s->req_cap) {
struct cap_hdr *h; struct cap_hdr *h;
for (h = fe->req_cap; h; h = h->next) for (h = fe->req_cap; h; h = h->next)
pool_free2(h->pool, s->req_cap[h->index]); pool_free(h->pool, s->req_cap[h->index]);
memset(s->req_cap, 0, fe->nb_req_cap * sizeof(void *)); memset(s->req_cap, 0, fe->nb_req_cap * sizeof(void *));
} }
if (s->res_cap) { if (s->res_cap) {
struct cap_hdr *h; struct cap_hdr *h;
for (h = fe->rsp_cap; h; h = h->next) for (h = fe->rsp_cap; h; h = h->next)
pool_free2(h->pool, s->res_cap[h->index]); pool_free(h->pool, s->res_cap[h->index]);
memset(s->res_cap, 0, fe->nb_rsp_cap * sizeof(void *)); memset(s->res_cap, 0, fe->nb_rsp_cap * sizeof(void *));
} }
@ -9550,7 +9550,7 @@ smp_fetch_uniqueid(const struct arg *args, struct sample *smp, const char *kw, v
return 0; return 0;
if (!smp->strm->unique_id) { if (!smp->strm->unique_id) {
if ((smp->strm->unique_id = pool_alloc2(pool2_uniqueid)) == NULL) if ((smp->strm->unique_id = pool_alloc(pool_head_uniqueid)) == NULL)
return 0; return 0;
smp->strm->unique_id[0] = '\0'; smp->strm->unique_id[0] = '\0';
} }
@ -11592,7 +11592,7 @@ static int smp_conv_req_capture(const struct arg *args, struct sample *smp, void
/* check for the memory allocation */ /* check for the memory allocation */
if (smp->strm->req_cap[hdr->index] == NULL) if (smp->strm->req_cap[hdr->index] == NULL)
smp->strm->req_cap[hdr->index] = pool_alloc2(hdr->pool); smp->strm->req_cap[hdr->index] = pool_alloc(hdr->pool);
if (smp->strm->req_cap[hdr->index] == NULL) if (smp->strm->req_cap[hdr->index] == NULL)
return 0; return 0;
@ -11633,7 +11633,7 @@ static int smp_conv_res_capture(const struct arg *args, struct sample *smp, void
/* check for the memory allocation */ /* check for the memory allocation */
if (smp->strm->res_cap[hdr->index] == NULL) if (smp->strm->res_cap[hdr->index] == NULL)
smp->strm->res_cap[hdr->index] = pool_alloc2(hdr->pool); smp->strm->res_cap[hdr->index] = pool_alloc(hdr->pool);
if (smp->strm->res_cap[hdr->index] == NULL) if (smp->strm->res_cap[hdr->index] == NULL)
return 0; return 0;
@ -11981,7 +11981,7 @@ enum act_return http_action_req_capture(struct act_rule *rule, struct proxy *px,
return ACT_RET_CONT; return ACT_RET_CONT;
if (cap[h->index] == NULL) if (cap[h->index] == NULL)
cap[h->index] = pool_alloc2(h->pool); cap[h->index] = pool_alloc(h->pool);
if (cap[h->index] == NULL) /* no more capture memory */ if (cap[h->index] == NULL) /* no more capture memory */
return ACT_RET_CONT; return ACT_RET_CONT;
@ -12022,7 +12022,7 @@ enum act_return http_action_req_capture_by_id(struct act_rule *rule, struct prox
return ACT_RET_CONT; return ACT_RET_CONT;
if (cap[h->index] == NULL) if (cap[h->index] == NULL)
cap[h->index] = pool_alloc2(h->pool); cap[h->index] = pool_alloc(h->pool);
if (cap[h->index] == NULL) /* no more capture memory */ if (cap[h->index] == NULL) /* no more capture memory */
return ACT_RET_CONT; return ACT_RET_CONT;
@ -12208,7 +12208,7 @@ enum act_return http_action_res_capture_by_id(struct act_rule *rule, struct prox
return ACT_RET_CONT; return ACT_RET_CONT;
if (cap[h->index] == NULL) if (cap[h->index] == NULL)
cap[h->index] = pool_alloc2(h->pool); cap[h->index] = pool_alloc(h->pool);
if (cap[h->index] == NULL) /* no more capture memory */ if (cap[h->index] == NULL) /* no more capture memory */
return ACT_RET_CONT; return ACT_RET_CONT;

4
src/proxy.c
View File

@ -855,7 +855,7 @@ struct task *manage_proxy(struct task *t)
p->id, p->fe_counters.cum_conn, p->be_counters.cum_conn); p->id, p->fe_counters.cum_conn, p->be_counters.cum_conn);
stop_proxy(p); stop_proxy(p);
/* try to free more memory */ /* try to free more memory */
pool_gc2(NULL); pool_gc(NULL);
} }
else { else {
next = tick_first(next, p->stop_time); next = tick_first(next, p->stop_time);
@ -872,7 +872,7 @@ struct task *manage_proxy(struct task *t)
if (unlikely(stopping && p->state == PR_STSTOPPED && p->table.current)) { if (unlikely(stopping && p->state == PR_STSTOPPED && p->table.current)) {
if (!p->table.syncing) { if (!p->table.syncing) {
stktable_trash_oldest(&p->table, p->table.current); stktable_trash_oldest(&p->table, p->table.current);
pool_gc2(NULL); pool_gc(NULL);
} }
if (p->table.current) { if (p->table.current) {
/* some entries still remain, let's recheck in one second */ /* some entries still remain, let's recheck in one second */

12
src/queue.c
View File

@ -22,15 +22,15 @@
#include <proto/task.h> #include <proto/task.h>
struct pool_head *pool2_pendconn; struct pool_head *pool_head_pendconn;
static void __pendconn_free(struct pendconn *p); static void __pendconn_free(struct pendconn *p);
/* perform minimal intializations, report 0 in case of error, 1 if OK. */ /* perform minimal intializations, report 0 in case of error, 1 if OK. */
int init_pendconn() int init_pendconn()
{ {
pool2_pendconn = create_pool("pendconn", sizeof(struct pendconn), MEM_F_SHARED); pool_head_pendconn = create_pool("pendconn", sizeof(struct pendconn), MEM_F_SHARED);
return pool2_pendconn != NULL; return pool_head_pendconn != NULL;
} }
/* returns the effective dynamic maxconn for a server, considering the minconn /* returns the effective dynamic maxconn for a server, considering the minconn
@ -172,7 +172,7 @@ struct pendconn *pendconn_add(struct stream *strm)
struct server *srv; struct server *srv;
int count; int count;
p = pool_alloc2(pool2_pendconn); p = pool_alloc(pool_head_pendconn);
if (!p) if (!p)
return NULL; return NULL;
@ -281,7 +281,7 @@ void pendconn_free(struct pendconn *p)
} }
p->strm->pend_pos = NULL; p->strm->pend_pos = NULL;
HA_ATOMIC_SUB(&p->strm->be->totpend, 1); HA_ATOMIC_SUB(&p->strm->be->totpend, 1);
pool_free2(pool2_pendconn, p); pool_free(pool_head_pendconn, p);
} }
/* Lock-free version of pendconn_free. */ /* Lock-free version of pendconn_free. */
@ -297,7 +297,7 @@ static void __pendconn_free(struct pendconn *p)
} }
p->strm->pend_pos = NULL; p->strm->pend_pos = NULL;
HA_ATOMIC_SUB(&p->strm->be->totpend, 1); HA_ATOMIC_SUB(&p->strm->be->totpend, 1);
pool_free2(pool2_pendconn, p); pool_free(pool_head_pendconn, p);
} }
/* /*

10
src/session.c
View File

@ -28,7 +28,7 @@
#include <proto/tcp_rules.h> #include <proto/tcp_rules.h>
#include <proto/vars.h> #include <proto/vars.h>
struct pool_head *pool2_session; struct pool_head *pool_head_session;
static int conn_complete_session(struct connection *conn); static int conn_complete_session(struct connection *conn);
static struct task *session_expire_embryonic(struct task *t); static struct task *session_expire_embryonic(struct task *t);
@ -42,7 +42,7 @@ struct session *session_new(struct proxy *fe, struct listener *li, enum obj_type
{ {
struct session *sess; struct session *sess;
sess = pool_alloc2(pool2_session); sess = pool_alloc(pool_head_session);
if (sess) { if (sess) {
sess->listener = li; sess->listener = li;
sess->fe = fe; sess->fe = fe;
@ -69,7 +69,7 @@ void session_free(struct session *sess)
listener_release(sess->listener); listener_release(sess->listener);
session_store_counters(sess); session_store_counters(sess);
vars_prune_per_sess(&sess->vars); vars_prune_per_sess(&sess->vars);
pool_free2(pool2_session, sess); pool_free(pool_head_session, sess);
HA_ATOMIC_SUB(&jobs, 1); HA_ATOMIC_SUB(&jobs, 1);
} }
@ -84,8 +84,8 @@ void conn_session_free(struct connection *conn)
/* perform minimal intializations, report 0 in case of error, 1 if OK. */ /* perform minimal intializations, report 0 in case of error, 1 if OK. */
int init_session() int init_session()
{ {
pool2_session = create_pool("session", sizeof(struct session), MEM_F_SHARED); pool_head_session = create_pool("session", sizeof(struct session), MEM_F_SHARED);
return pool2_session != NULL; return pool_head_session != NULL;
} }
/* count a new session to keep frontend, listener and track stats up to date */ /* count a new session to keep frontend, listener and track stats up to date */

16
src/signal.c
View File

@ -27,7 +27,7 @@
int signal_queue_len; /* length of signal queue, <= MAX_SIGNAL (1 entry per signal max) */ int signal_queue_len; /* length of signal queue, <= MAX_SIGNAL (1 entry per signal max) */
int signal_queue[MAX_SIGNAL]; /* in-order queue of received signals */ int signal_queue[MAX_SIGNAL]; /* in-order queue of received signals */
struct signal_descriptor signal_state[MAX_SIGNAL]; struct signal_descriptor signal_state[MAX_SIGNAL];
struct pool_head *pool2_sig_handlers = NULL; struct pool_head *pool_head_sig_handlers = NULL;
sigset_t blocked_sig; sigset_t blocked_sig;
int signal_pending = 0; /* non-zero if t least one signal remains unprocessed */ int signal_pending = 0; /* non-zero if t least one signal remains unprocessed */
@ -130,8 +130,8 @@ int signal_init()
for (sig = 0; sig < MAX_SIGNAL; sig++) for (sig = 0; sig < MAX_SIGNAL; sig++)
LIST_INIT(&signal_state[sig].handlers); LIST_INIT(&signal_state[sig].handlers);
pool2_sig_handlers = create_pool("sig_handlers", sizeof(struct sig_handler), MEM_F_SHARED); pool_head_sig_handlers = create_pool("sig_handlers", sizeof(struct sig_handler), MEM_F_SHARED);
return pool2_sig_handlers != NULL; return pool_head_sig_handlers != NULL;
} }
/* releases all registered signal handlers */ /* releases all registered signal handlers */
@ -145,7 +145,7 @@ void deinit_signals()
signal(sig, SIG_DFL); signal(sig, SIG_DFL);
list_for_each_entry_safe(sh, shb, &signal_state[sig].handlers, list) { list_for_each_entry_safe(sh, shb, &signal_state[sig].handlers, list) {
LIST_DEL(&sh->list); LIST_DEL(&sh->list);
pool_free2(pool2_sig_handlers, sh); pool_free(pool_head_sig_handlers, sh);
} }
} }
HA_SPIN_DESTROY(&signals_lock); HA_SPIN_DESTROY(&signals_lock);
@ -172,7 +172,7 @@ struct sig_handler *signal_register_fct(int sig, void (*fct)(struct sig_handler
if (!fct) if (!fct)
return NULL; return NULL;
sh = pool_alloc2(pool2_sig_handlers); sh = pool_alloc(pool_head_sig_handlers);
if (!sh) if (!sh)
return NULL; return NULL;
@ -204,7 +204,7 @@ struct sig_handler *signal_register_task(int sig, struct task *task, int reason)
if (!task) if (!task)
return NULL; return NULL;
sh = pool_alloc2(pool2_sig_handlers); sh = pool_alloc(pool_head_sig_handlers);
if (!sh) if (!sh)
return NULL; return NULL;
@ -221,7 +221,7 @@ struct sig_handler *signal_register_task(int sig, struct task *task, int reason)
void signal_unregister_handler(struct sig_handler *handler) void signal_unregister_handler(struct sig_handler *handler)
{ {
LIST_DEL(&handler->list); LIST_DEL(&handler->list);
pool_free2(pool2_sig_handlers, handler); pool_free(pool_head_sig_handlers, handler);
} }
/* Immediately unregister a handler so that no further signals may be delivered /* Immediately unregister a handler so that no further signals may be delivered
@ -243,7 +243,7 @@ void signal_unregister_target(int sig, void *target)
list_for_each_entry_safe(sh, shb, &signal_state[sig].handlers, list) { list_for_each_entry_safe(sh, shb, &signal_state[sig].handlers, list) {
if (sh->handler == target) { if (sh->handler == target) {
LIST_DEL(&sh->list); LIST_DEL(&sh->list);
pool_free2(pool2_sig_handlers, sh); pool_free(pool_head_sig_handlers, sh);
break; break;
} }
} }

24
src/ssl_sock.c
View File

@ -258,7 +258,7 @@ struct ssl_capture {
unsigned char ciphersuite_len; unsigned char ciphersuite_len;
char ciphersuite[0]; char ciphersuite[0];
}; };
struct pool_head *pool2_ssl_capture = NULL; struct pool_head *pool_head_ssl_capture = NULL;
static int ssl_capture_ptr_index = -1; static int ssl_capture_ptr_index = -1;
#if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0) #if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0)
@ -1536,7 +1536,7 @@ void ssl_sock_parse_clienthello(int write_p, int version, int content_type,
if (msg + rec_len > end || msg + rec_len < msg) if (msg + rec_len > end || msg + rec_len < msg)
return; return;
capture = pool_alloc_dirty(pool2_ssl_capture); capture = pool_alloc_dirty(pool_head_ssl_capture);
if (!capture) if (!capture)
return; return;
/* Compute the xxh64 of the ciphersuite. */ /* Compute the xxh64 of the ciphersuite. */
@ -4906,7 +4906,7 @@ static int ssl_sock_init(struct connection *conn)
conn->xprt_ctx = SSL_new(objt_server(conn->target)->ssl_ctx.ctx); conn->xprt_ctx = SSL_new(objt_server(conn->target)->ssl_ctx.ctx);
if (!conn->xprt_ctx) { if (!conn->xprt_ctx) {
if (may_retry--) { if (may_retry--) {
pool_gc2(NULL); pool_gc(NULL);
goto retry_connect; goto retry_connect;
} }
conn->err_code = CO_ER_SSL_NO_MEM; conn->err_code = CO_ER_SSL_NO_MEM;
@ -4918,7 +4918,7 @@ static int ssl_sock_init(struct connection *conn)
SSL_free(conn->xprt_ctx); SSL_free(conn->xprt_ctx);
conn->xprt_ctx = NULL; conn->xprt_ctx = NULL;
if (may_retry--) { if (may_retry--) {
pool_gc2(NULL); pool_gc(NULL);
goto retry_connect; goto retry_connect;
} }
conn->err_code = CO_ER_SSL_NO_MEM; conn->err_code = CO_ER_SSL_NO_MEM;
@ -4930,7 +4930,7 @@ static int ssl_sock_init(struct connection *conn)
SSL_free(conn->xprt_ctx); SSL_free(conn->xprt_ctx);
conn->xprt_ctx = NULL; conn->xprt_ctx = NULL;
if (may_retry--) { if (may_retry--) {
pool_gc2(NULL); pool_gc(NULL);
goto retry_connect; goto retry_connect;
} }
conn->err_code = CO_ER_SSL_NO_MEM; conn->err_code = CO_ER_SSL_NO_MEM;
@ -4965,7 +4965,7 @@ static int ssl_sock_init(struct connection *conn)
conn->xprt_ctx = SSL_new(objt_listener(conn->target)->bind_conf->initial_ctx); conn->xprt_ctx = SSL_new(objt_listener(conn->target)->bind_conf->initial_ctx);
if (!conn->xprt_ctx) { if (!conn->xprt_ctx) {
if (may_retry--) { if (may_retry--) {
pool_gc2(NULL); pool_gc(NULL);
goto retry_accept; goto retry_accept;
} }
conn->err_code = CO_ER_SSL_NO_MEM; conn->err_code = CO_ER_SSL_NO_MEM;
@ -4977,7 +4977,7 @@ static int ssl_sock_init(struct connection *conn)
SSL_free(conn->xprt_ctx); SSL_free(conn->xprt_ctx);
conn->xprt_ctx = NULL; conn->xprt_ctx = NULL;
if (may_retry--) { if (may_retry--) {
pool_gc2(NULL); pool_gc(NULL);
goto retry_accept; goto retry_accept;
} }
conn->err_code = CO_ER_SSL_NO_MEM; conn->err_code = CO_ER_SSL_NO_MEM;
@ -4989,7 +4989,7 @@ static int ssl_sock_init(struct connection *conn)
SSL_free(conn->xprt_ctx); SSL_free(conn->xprt_ctx);
conn->xprt_ctx = NULL; conn->xprt_ctx = NULL;
if (may_retry--) { if (may_retry--) {
pool_gc2(NULL); pool_gc(NULL);
goto retry_accept; goto retry_accept;
} }
conn->err_code = CO_ER_SSL_NO_MEM; conn->err_code = CO_ER_SSL_NO_MEM;
@ -8113,13 +8113,13 @@ static int ssl_parse_global_capture_cipherlist(char **args, int section_type, st
if (ret != 0) if (ret != 0)
return ret; return ret;
if (pool2_ssl_capture) { if (pool_head_ssl_capture) {
memprintf(err, "'%s' is already configured.", args[0]); memprintf(err, "'%s' is already configured.", args[0]);
return -1; return -1;
} }
pool2_ssl_capture = create_pool("ssl-capture", sizeof(struct ssl_capture) + global_ssl.capture_cipherlist, MEM_F_SHARED); pool_head_ssl_capture = create_pool("ssl-capture", sizeof(struct ssl_capture) + global_ssl.capture_cipherlist, MEM_F_SHARED);
if (!pool2_ssl_capture) { if (!pool_head_ssl_capture) {
memprintf(err, "Out of memory error."); memprintf(err, "Out of memory error.");
return -1; return -1;
} }
@ -8742,7 +8742,7 @@ static void ssl_sock_sctl_free_func(void *parent, void *ptr, CRYPTO_EX_DATA *ad,
#endif #endif
static void ssl_sock_capture_free_func(void *parent, void *ptr, CRYPTO_EX_DATA *ad, int idx, long argl, void *argp) static void ssl_sock_capture_free_func(void *parent, void *ptr, CRYPTO_EX_DATA *ad, int idx, long argl, void *argp)
{ {
pool_free2(pool2_ssl_capture, ptr); pool_free(pool_head_ssl_capture, ptr);
} }
__attribute__((constructor)) __attribute__((constructor))

4
src/stick_table.c
View File

@ -51,7 +51,7 @@ static THREAD_LOCAL struct stktable_key static_table_key;
void __stksess_free(struct stktable *t, struct stksess *ts) void __stksess_free(struct stktable *t, struct stksess *ts)
{ {
t->current--; t->current--;
pool_free2(t->pool, (void *)ts - t->data_size); pool_free(t->pool, (void *)ts - t->data_size);
} }
/* /*
@ -226,7 +226,7 @@ struct stksess *__stksess_new(struct stktable *t, struct stktable_key *key)
return NULL; return NULL;
} }
ts = pool_alloc2(t->pool); ts = pool_alloc(t->pool);
if (ts) { if (ts) {
t->current++; t->current++;
ts = (void *)ts + t->data_size; ts = (void *)ts + t->data_size;

42
src/stream.c
View File

@ -60,7 +60,7 @@
#include <proto/tcp_rules.h> #include <proto/tcp_rules.h>
#include <proto/vars.h> #include <proto/vars.h>
struct pool_head *pool2_stream; struct pool_head *pool_head_stream;
struct list streams; struct list streams;
__decl_hathreads(HA_SPINLOCK_T streams_lock); __decl_hathreads(HA_SPINLOCK_T streams_lock);
@ -100,7 +100,7 @@ struct stream *stream_new(struct session *sess, enum obj_type *origin)
struct conn_stream *cs = objt_cs(origin); struct conn_stream *cs = objt_cs(origin);
struct appctx *appctx = objt_appctx(origin); struct appctx *appctx = objt_appctx(origin);
if (unlikely((s = pool_alloc2(pool2_stream)) == NULL)) if (unlikely((s = pool_alloc(pool_head_stream)) == NULL))
goto out_fail_alloc; goto out_fail_alloc;
/* minimum stream initialization required for an embryonic stream is /* minimum stream initialization required for an embryonic stream is
@ -284,7 +284,7 @@ struct stream *stream_new(struct session *sess, enum obj_type *origin)
task_free(t); task_free(t);
out_fail_alloc: out_fail_alloc:
LIST_DEL(&s->list); LIST_DEL(&s->list);
pool_free2(pool2_stream, s); pool_free(pool_head_stream, s);
return NULL; return NULL;
} }
@ -355,8 +355,8 @@ static void stream_free(struct stream *s)
} }
if (s->txn) { if (s->txn) {
pool_free2(pool2_hdr_idx, s->txn->hdr_idx.v); pool_free(pool_head_hdr_idx, s->txn->hdr_idx.v);
pool_free2(pool2_http_txn, s->txn); pool_free(pool_head_http_txn, s->txn);
s->txn = NULL; s->txn = NULL;
} }
@ -364,8 +364,8 @@ static void stream_free(struct stream *s)
flt_stream_release(s, 0); flt_stream_release(s, 0);
if (fe) { if (fe) {
pool_free2(fe->rsp_cap_pool, s->res_cap); pool_free(fe->rsp_cap_pool, s->res_cap);
pool_free2(fe->req_cap_pool, s->req_cap); pool_free(fe->req_cap_pool, s->req_cap);
} }
/* Cleanup all variable contexts. */ /* Cleanup all variable contexts. */
@ -394,21 +394,21 @@ static void stream_free(struct stream *s)
/* FIXME: for now we have a 1:1 relation between stream and session so /* FIXME: for now we have a 1:1 relation between stream and session so
* the stream must free the session. * the stream must free the session.
*/ */
pool_free2(pool2_stream, s); pool_free(pool_head_stream, s);
/* We may want to free the maximum amount of pools if the proxy is stopping */ /* We may want to free the maximum amount of pools if the proxy is stopping */
if (fe && unlikely(fe->state == PR_STSTOPPED)) { if (fe && unlikely(fe->state == PR_STSTOPPED)) {
pool_flush2(pool2_buffer); pool_flush(pool_head_buffer);
pool_flush2(pool2_http_txn); pool_flush(pool_head_http_txn);
pool_flush2(pool2_hdr_idx); pool_flush(pool_head_hdr_idx);
pool_flush2(pool2_requri); pool_flush(pool_head_requri);
pool_flush2(pool2_capture); pool_flush(pool_head_capture);
pool_flush2(pool2_stream); pool_flush(pool_head_stream);
pool_flush2(pool2_session); pool_flush(pool_head_session);
pool_flush2(pool2_connection); pool_flush(pool_head_connection);
pool_flush2(pool2_pendconn); pool_flush(pool_head_pendconn);
pool_flush2(fe->req_cap_pool); pool_flush(fe->req_cap_pool);
pool_flush2(fe->rsp_cap_pool); pool_flush(fe->rsp_cap_pool);
} }
} }
@ -470,8 +470,8 @@ int init_stream()
{ {
LIST_INIT(&streams); LIST_INIT(&streams);
HA_SPIN_INIT(&streams_lock); HA_SPIN_INIT(&streams_lock);
pool2_stream = create_pool("stream", sizeof(struct stream), MEM_F_SHARED); pool_head_stream = create_pool("stream", sizeof(struct stream), MEM_F_SHARED);
return pool2_stream != NULL; return pool_head_stream != NULL;
} }
void stream_process_counters(struct stream *s) void stream_process_counters(struct stream *s)

12
src/task.c
View File

@ -24,12 +24,12 @@
#include <proto/stream.h> #include <proto/stream.h>
#include <proto/task.h> #include <proto/task.h>
struct pool_head *pool2_task; struct pool_head *pool_head_task;
/* This is the memory pool containing all the signal structs. These /* This is the memory pool containing all the signal structs. These
* struct are used to store each requiered signal between two tasks. * struct are used to store each requiered signal between two tasks.
*/ */
struct pool_head *pool2_notification; struct pool_head *pool_head_notification;
unsigned int nb_tasks = 0; unsigned int nb_tasks = 0;
unsigned long active_tasks_mask = 0; /* Mask of threads with active tasks */ unsigned long active_tasks_mask = 0; /* Mask of threads with active tasks */
@ -342,11 +342,11 @@ int init_task()
memset(&rqueue, 0, sizeof(rqueue)); memset(&rqueue, 0, sizeof(rqueue));
HA_SPIN_INIT(&wq_lock); HA_SPIN_INIT(&wq_lock);
HA_SPIN_INIT(&rq_lock); HA_SPIN_INIT(&rq_lock);
pool2_task = create_pool("task", sizeof(struct task), MEM_F_SHARED); pool_head_task = create_pool("task", sizeof(struct task), MEM_F_SHARED);
if (!pool2_task) if (!pool_head_task)
return 0; return 0;
pool2_notification = create_pool("notification", sizeof(struct notification), MEM_F_SHARED); pool_head_notification = create_pool("notification", sizeof(struct notification), MEM_F_SHARED);
if (!pool2_notification) if (!pool_head_notification)
return 0; return 0;
return 1; return 1;
} }

2
src/tcp_rules.c
View File

@ -214,7 +214,7 @@ resume_execution:
goto missing_data; goto missing_data;
if (cap[h->index] == NULL) if (cap[h->index] == NULL)
cap[h->index] = pool_alloc2(h->pool); cap[h->index] = pool_alloc(h->pool);
if (cap[h->index] == NULL) /* no more capture memory */ if (cap[h->index] == NULL) /* no more capture memory */
continue; continue;

4
src/vars.c
View File

@ -103,7 +103,7 @@ unsigned int var_clear(struct var *var)
size += var->data.u.meth.str.len; size += var->data.u.meth.str.len;
} }
LIST_DEL(&var->l); LIST_DEL(&var->l);
pool_free2(var_pool, var); pool_free(var_pool, var);
size += sizeof(struct var); size += sizeof(struct var);
return size; return size;
} }
@ -359,7 +359,7 @@ static int sample_store(struct vars *vars, const char *name, struct sample *smp)
return 0; return 0;
/* Create new entry. */ /* Create new entry. */
var = pool_alloc2(var_pool); var = pool_alloc(var_pool);
if (!var) if (!var)
return 0; return 0;
LIST_ADDQ(&vars->head, &var->l); LIST_ADDQ(&vars->head, &var->l);