new file mode 100644
--- /dev/null
+++ b/src/core/ngx_palloc.c
@@ -0,0 +1,215 @@
+
+/*
+ * Copyright (C) Igor Sysoev
+ */
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+
+
+ngx_pool_t *ngx_create_pool(size_t size, ngx_log_t *log)
+{
+    ngx_pool_t  *p;
+
+    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;
+}
+
+
+void ngx_destroy_pool(ngx_pool_t *pool)
+{
+    ngx_pool_t        *p, *n;
+    ngx_pool_large_t  *l;
+
+    for (l = pool->large; l; l = l->next) {
+
+        ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
+                       "free: " PTR_FMT, l->alloc);
+
+        if (l->alloc) {
+            free(l->alloc);
+        }
+    }
+
+#if (NGX_DEBUG)
+
+    /*
+     * we could allocate the pool->log from this pool
+     * so we can not use this log while the free()ing the pool
+     */
+
+    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);
+
+        if (n == NULL) {
+            break;
+        }
+    }
+
+#endif
+
+    for (p = pool, n = pool->next; /* void */; p = n, n = n->next) {
+        free(p);
+
+        if (n == NULL) {
+            break;
+        }
+    }
+}
+
+
+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;
+}
+
+
+ngx_int_t ngx_pfree(ngx_pool_t *pool, void *p)
+{
+    ngx_pool_large_t  *l;
+
+    for (l = pool->large; l; l = l->next) {
+        if (p == l->alloc) {
+            ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
+                           "free: " PTR_FMT, l->alloc);
+            free(l->alloc);
+            l->alloc = NULL;
+
+            return NGX_OK;
+        }
+    }
+
+    return NGX_DECLINED;
+}
+
+
+void *ngx_pcalloc(ngx_pool_t *pool, size_t size)
+{
+    void *p;
+
+    p = ngx_palloc(pool, size);
+    if (p) {
+        ngx_memzero(p, size);
+    }
+
+    return p;
+}
+
+#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