ngx_pool_t * ngx_create_pool(size_t size, ngx_log_t *log) { ngx_pool_t *p; p = (ngx_pool_t*)ngx_memalign(NGX_POOL_ALIGNMENT, size, log); if (p == NULL) { return NULL; } p->d.last = (u_char *) p + sizeof(ngx_pool_t); p->d.end = (u_char *) p + size; p->d.next = NULL; p->d.failed = 0; size = size - sizeof(ngx_pool_t); p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL; p->current = p; p->chain = NULL; p->large = NULL; p->cleanup = NULL; p->log = log; return p; }
static void * ngx_palloc_block(ngx_pool_t *pool, size_t size) { u_char *m; size_t psize; ngx_pool_t *p, *newp, *current; psize = (size_t) (pool->d.end - (u_char *) pool); m = (u_char*)ngx_memalign(NGX_POOL_ALIGNMENT, psize/*, pool->log*/); if (m == NULL) { return NULL; } newp = (ngx_pool_t *) m; newp->d.end = m + psize; newp->d.next = NULL; newp->d.failed = 0; m += sizeof(ngx_pool_data_t); m = ngx_align_ptr(m, NGX_ALIGNMENT); newp->d.last = m + size; current = pool->current; for (p = current; p->d.next; p = p->d.next) { if (p->d.failed++ > 4) { current = p->d.next; } } p->d.next = newp; pool->current = current ? current : newp; return m; }
void * ngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment) { void *p; ngx_pool_large_t *large; p = ngx_memalign(alignment, size/*, pool->log*/); if (p == NULL) { return NULL; } large = (ngx_pool_large_t*)ngx_palloc(pool, sizeof(ngx_pool_large_t)); if (large == NULL) { ngx_free(p); return NULL; } large->alloc = p; large->next = pool->large; pool->large = large; return p; }
void *ngx_palloc(ngx_pool_t *pool, size_t size) { 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) { m = ngx_align(p->last); if ((size_t) (p->end - m) >= size) { p->last = m + size ; return m; } if (n == NULL) { break; } } /* allocate a new pool block */ if (!(n = ngx_create_pool((size_t) (p->end - (char *) p), p->log))) { return NULL; } p->next = n; m = n->last; n->last += size; return m; } /* allocate a large block */ large = NULL; last = NULL; if (pool->large) { for (last = pool->large; /* void */ ; last = last->next) { if (last->alloc == NULL) { large = last; last = NULL; break; } if (last->next == NULL) { break; } } } if (large == NULL) { if (!(large = ngx_palloc(pool, sizeof(ngx_pool_large_t)))) { return NULL; } large->next = NULL; } #if 0 if (!(p = ngx_memalign(ngx_pagesize, size, pool->log))) { return NULL; } #else if (!(p = ngx_alloc(size, pool->log))) { return NULL; } #endif if (pool->large == NULL) { pool->large = large; } else if (last) { last->next = large; } large->alloc = p; return p; }
static void * ngx_http_js_memalign(void *mem, size_t alignment, size_t size) { return ngx_memalign(alignment, size, ngx_cycle->log); }