2002-08-07 00:39:45 +08:00
|
|
|
|
2004-09-28 16:34:51 +08:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2002-2004 Igor Sysoev
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
2002-08-07 00:39:45 +08:00
|
|
|
#include <ngx_config.h>
|
2003-06-03 23:42:58 +08:00
|
|
|
#include <ngx_core.h>
|
2002-08-07 00:39:45 +08:00
|
|
|
|
|
|
|
|
|
|
|
ngx_pool_t *ngx_create_pool(size_t size, ngx_log_t *log)
|
|
|
|
{
|
2003-11-21 14:30:49 +08:00
|
|
|
ngx_pool_t *p;
|
2002-08-07 00:39:45 +08:00
|
|
|
|
2003-11-21 14:30:49 +08:00
|
|
|
if (!(p = ngx_alloc(size, log))) {
|
|
|
|
return NULL;
|
|
|
|
}
|
2002-08-07 00:39:45 +08:00
|
|
|
|
|
|
|
p->last = (char *) p + sizeof(ngx_pool_t);
|
|
|
|
p->end = (char *) p + size;
|
|
|
|
p->next = NULL;
|
|
|
|
p->large = NULL;
|
|
|
|
p->log = log;
|
|
|
|
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2003-10-23 14:13:16 +08:00
|
|
|
|
2002-08-07 00:39:45 +08:00
|
|
|
void ngx_destroy_pool(ngx_pool_t *pool)
|
|
|
|
{
|
|
|
|
ngx_pool_t *p, *n;
|
|
|
|
ngx_pool_large_t *l;
|
|
|
|
|
2002-09-11 23:18:33 +08:00
|
|
|
for (l = pool->large; l; l = l->next) {
|
2004-02-12 01:08:49 +08:00
|
|
|
|
|
|
|
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
|
2004-02-25 01:31:46 +08:00
|
|
|
"free: " PTR_FMT, l->alloc);
|
2004-02-12 01:08:49 +08:00
|
|
|
|
2003-10-23 14:13:16 +08:00
|
|
|
if (l->alloc) {
|
|
|
|
free(l->alloc);
|
|
|
|
}
|
2002-09-11 23:18:33 +08:00
|
|
|
}
|
2002-08-07 00:39:45 +08:00
|
|
|
|
2004-02-12 01:08:49 +08:00
|
|
|
#if (NGX_DEBUG)
|
|
|
|
|
2003-08-08 23:13:24 +08:00
|
|
|
/*
|
2004-02-12 01:08:49 +08:00
|
|
|
* we could allocate the pool->log from this pool
|
|
|
|
* so we can not use this log while the free()ing the pool
|
2003-08-08 23:13:24 +08:00
|
|
|
*/
|
2003-08-06 22:43:50 +08:00
|
|
|
|
2003-08-08 23:13:24 +08:00
|
|
|
for (p = pool, n = pool->next; /* void */; p = n, n = n->next) {
|
2004-09-23 14:32:00 +08:00
|
|
|
ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
|
|
|
|
"free: " PTR_FMT ", unused: " SIZE_T_FMT,
|
|
|
|
p, p->end - p->last);
|
2003-09-25 03:51:12 +08:00
|
|
|
|
|
|
|
if (n == NULL) {
|
|
|
|
break;
|
|
|
|
}
|
2003-08-08 23:13:24 +08:00
|
|
|
}
|
2004-02-12 01:08:49 +08:00
|
|
|
|
2002-12-25 01:30:59 +08:00
|
|
|
#endif
|
2003-08-08 23:13:24 +08:00
|
|
|
|
|
|
|
for (p = pool, n = pool->next; /* void */; p = n, n = n->next) {
|
2002-08-07 00:39:45 +08:00
|
|
|
free(p);
|
2003-08-08 23:13:24 +08:00
|
|
|
|
|
|
|
if (n == NULL) {
|
|
|
|
break;
|
|
|
|
}
|
2002-08-07 00:39:45 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2003-10-23 14:13:16 +08:00
|
|
|
|
2002-08-07 00:39:45 +08:00
|
|
|
void *ngx_palloc(ngx_pool_t *pool, size_t size)
|
|
|
|
{
|
2003-06-12 13:54:39 +08:00
|
|
|
char *m;
|
2002-08-07 00:39:45 +08:00
|
|
|
ngx_pool_t *p, *n;
|
|
|
|
ngx_pool_large_t *large, *last;
|
|
|
|
|
2004-09-18 00:07:35 +08:00
|
|
|
if (size <= (size_t) NGX_MAX_ALLOC_FROM_POOL
|
2004-09-23 14:32:00 +08:00
|
|
|
&& size <= (size_t) (pool->end - (char *) pool) - sizeof(ngx_pool_t))
|
2004-09-18 00:07:35 +08:00
|
|
|
{
|
2002-08-07 00:39:45 +08:00
|
|
|
for (p = pool, n = pool->next; /* void */; p = n, n = n->next) {
|
2003-06-12 13:54:39 +08:00
|
|
|
m = ngx_align(p->last);
|
|
|
|
|
|
|
|
if ((size_t) (p->end - m) >= size) {
|
|
|
|
p->last = m + size ;
|
2002-08-07 00:39:45 +08:00
|
|
|
|
|
|
|
return m;
|
|
|
|
}
|
|
|
|
|
2002-12-25 01:30:59 +08:00
|
|
|
if (n == NULL) {
|
2002-08-07 00:39:45 +08:00
|
|
|
break;
|
2002-12-25 01:30:59 +08:00
|
|
|
}
|
2002-08-07 00:39:45 +08:00
|
|
|
}
|
|
|
|
|
2004-09-15 03:39:54 +08:00
|
|
|
/* allocate a new pool block */
|
2003-10-23 14:13:16 +08:00
|
|
|
|
2003-11-21 14:30:49 +08:00
|
|
|
if (!(n = ngx_create_pool((size_t) (p->end - (char *) p), p->log))) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2002-08-07 00:39:45 +08:00
|
|
|
p->next = n;
|
|
|
|
m = n->last;
|
|
|
|
n->last += size;
|
2003-10-23 14:13:16 +08:00
|
|
|
|
2002-08-07 00:39:45 +08:00
|
|
|
return m;
|
2003-10-23 14:13:16 +08:00
|
|
|
}
|
2002-08-07 00:39:45 +08:00
|
|
|
|
2004-09-15 03:39:54 +08:00
|
|
|
/* allocate a large block */
|
2003-10-23 14:13:16 +08:00
|
|
|
|
|
|
|
large = NULL;
|
|
|
|
last = NULL;
|
|
|
|
|
|
|
|
if (pool->large) {
|
2004-09-23 14:32:00 +08:00
|
|
|
for (last = pool->large; /* void */ ; last = last->next) {
|
2003-10-23 14:13:16 +08:00
|
|
|
if (last->alloc == NULL) {
|
|
|
|
large = last;
|
|
|
|
last = NULL;
|
|
|
|
break;
|
2002-08-07 00:39:45 +08:00
|
|
|
}
|
|
|
|
|
2003-10-23 14:13:16 +08:00
|
|
|
if (last->next == NULL) {
|
|
|
|
break;
|
|
|
|
}
|
2002-08-07 00:39:45 +08:00
|
|
|
}
|
2003-10-23 14:13:16 +08:00
|
|
|
}
|
2002-08-07 00:39:45 +08:00
|
|
|
|
2003-10-23 14:13:16 +08:00
|
|
|
if (large == NULL) {
|
2003-11-21 14:30:49 +08:00
|
|
|
if (!(large = ngx_palloc(pool, sizeof(ngx_pool_large_t)))) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2003-10-23 14:13:16 +08:00
|
|
|
large->next = NULL;
|
|
|
|
}
|
2002-08-07 00:39:45 +08:00
|
|
|
|
2004-06-09 00:26:37 +08:00
|
|
|
#if 0
|
2004-06-07 03:49:18 +08:00
|
|
|
if (!(p = ngx_memalign(ngx_pagesize, size, pool->log))) {
|
2003-11-21 14:30:49 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
2004-06-09 00:26:37 +08:00
|
|
|
#else
|
|
|
|
if (!(p = ngx_alloc(size, pool->log))) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
#endif
|
2002-08-07 00:39:45 +08:00
|
|
|
|
2003-10-23 14:13:16 +08:00
|
|
|
if (pool->large == NULL) {
|
|
|
|
pool->large = large;
|
|
|
|
|
|
|
|
} else if (last) {
|
|
|
|
last->next = large;
|
|
|
|
}
|
|
|
|
|
|
|
|
large->alloc = p;
|
2002-08-07 00:39:45 +08:00
|
|
|
|
2003-10-23 14:13:16 +08:00
|
|
|
return p;
|
|
|
|
}
|
2002-08-07 00:39:45 +08:00
|
|
|
|
2003-10-23 14:13:16 +08:00
|
|
|
|
2004-09-23 14:32:00 +08:00
|
|
|
ngx_int_t ngx_pfree(ngx_pool_t *pool, void *p)
|
2003-10-23 14:13:16 +08:00
|
|
|
{
|
|
|
|
ngx_pool_large_t *l;
|
|
|
|
|
|
|
|
for (l = pool->large; l; l = l->next) {
|
|
|
|
if (p == l->alloc) {
|
2004-02-12 01:08:49 +08:00
|
|
|
ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
|
2004-02-25 01:31:46 +08:00
|
|
|
"free: " PTR_FMT, l->alloc);
|
2003-10-23 14:13:16 +08:00
|
|
|
free(l->alloc);
|
|
|
|
l->alloc = NULL;
|
2004-09-23 14:32:00 +08:00
|
|
|
|
|
|
|
return NGX_OK;
|
2003-10-23 14:13:16 +08:00
|
|
|
}
|
2002-08-07 00:39:45 +08:00
|
|
|
}
|
2004-09-23 14:32:00 +08:00
|
|
|
|
|
|
|
return NGX_DECLINED;
|
2002-08-07 00:39:45 +08:00
|
|
|
}
|
|
|
|
|
2003-10-23 14:13:16 +08:00
|
|
|
|
2002-08-07 00:39:45 +08:00
|
|
|
void *ngx_pcalloc(ngx_pool_t *pool, size_t size)
|
|
|
|
{
|
|
|
|
void *p;
|
|
|
|
|
|
|
|
p = ngx_palloc(pool, size);
|
2002-12-25 01:30:59 +08:00
|
|
|
if (p) {
|
2002-08-07 00:39:45 +08:00
|
|
|
ngx_memzero(p, size);
|
2002-12-25 01:30:59 +08:00
|
|
|
}
|
2002-08-07 00:39:45 +08:00
|
|
|
|
|
|
|
return p;
|
|
|
|
}
|
2004-06-07 03:49:18 +08:00
|
|
|
|
|
|
|
#if 0
|
|
|
|
|
|
|
|
static void *ngx_get_cached_block(size_t size)
|
|
|
|
{
|
|
|
|
void *p;
|
|
|
|
ngx_cached_block_slot_t *slot;
|
|
|
|
|
|
|
|
if (ngx_cycle->cache == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
slot = &ngx_cycle->cache[(size + ngx_pagesize - 1) / ngx_pagesize];
|
|
|
|
|
|
|
|
slot->tries++;
|
|
|
|
|
|
|
|
if (slot->number) {
|
|
|
|
p = slot->block;
|
|
|
|
slot->block = slot->block->next;
|
|
|
|
slot->number--;
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|