nginx/src/core/ngx_palloc.c

216 lines
4.0 KiB
C
Raw Normal View History

/*
* Copyright (C) 2002-2004 Igor Sysoev
*/
#include <ngx_config.h>
2003-06-03 23:42:58 +08:00
#include <ngx_core.h>
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;
2003-11-21 14:30:49 +08:00
if (!(p = ngx_alloc(size, log))) {
return NULL;
}
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
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
}
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) {
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) {
free(p);
2003-08-08 23:13:24 +08:00
if (n == NULL) {
break;
}
}
}
2003-10-23 14:13:16 +08:00
void *ngx_palloc(ngx_pool_t *pool, size_t size)
{
2003-06-12 13:54:39 +08:00
char *m;
ngx_pool_t *p, *n;
ngx_pool_large_t *large, *last;
if (size <= (size_t) NGX_MAX_ALLOC_FROM_POOL
&& size <= (size_t) (pool->end - (char *) pool) - sizeof(ngx_pool_t))
{
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 ;
return m;
}
2002-12-25 01:30:59 +08:00
if (n == NULL) {
break;
2002-12-25 01:30:59 +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;
}
p->next = n;
m = n->last;
n->last += size;
2003-10-23 14:13:16 +08:00
return m;
2003-10-23 14:13:16 +08:00
}
/* allocate a large block */
2003-10-23 14:13:16 +08:00
large = NULL;
last = NULL;
if (pool->large) {
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;
}
2003-10-23 14:13:16 +08:00
if (last->next == NULL) {
break;
}
}
2003-10-23 14:13:16 +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;
}
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
2003-10-23 14:13:16 +08:00
if (pool->large == NULL) {
pool->large = large;
} else if (last) {
last->next = large;
}
large->alloc = p;
2003-10-23 14:13:16 +08:00
return p;
}
2003-10-23 14:13:16 +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;
return NGX_OK;
2003-10-23 14:13:16 +08:00
}
}
return NGX_DECLINED;
}
2003-10-23 14:13:16 +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) {
ngx_memzero(p, size);
2002-12-25 01:30:59 +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