# HG changeset patch
# User YujunLiu <liuyujun@fingera.cn>
# Date 1559636624 -28800
#      Tue Jun 04 16:23:44 2019 +0800
# Node ID 9950434a898ddcc8def73f23d31e11f4d8468f7c
# Parent  d964b0aee8e715bc6df4112b8b6ff23540c00d79
make ngx_pool clear

diff -r d964b0aee8e7 -r 9950434a898d src/core/ngx_palloc.c
--- a/src/core/ngx_palloc.c	Thu May 23 16:49:22 2019 +0300
+++ b/src/core/ngx_palloc.c	Tue Jun 04 16:23:44 2019 +0800
@@ -33,7 +33,7 @@
     size = size - sizeof(ngx_pool_t);
     p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL;
 
-    p->current = p;
+    p->current = &p->d;
     p->chain = NULL;
     p->large = NULL;
     p->cleanup = NULL;
@@ -46,7 +46,7 @@
 void
 ngx_destroy_pool(ngx_pool_t *pool)
 {
-    ngx_pool_t          *p, *n;
+    ngx_pool_data_t     *p, *n;
     ngx_pool_large_t    *l;
     ngx_pool_cleanup_t  *c;
 
@@ -86,12 +86,9 @@
         }
     }
 
-    for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
+    for (p = &pool->d; p; p = n) {
+        n = p->next;
         ngx_free(p);
-
-        if (n == NULL) {
-            break;
-        }
     }
 }
 
@@ -99,7 +96,7 @@
 void
 ngx_reset_pool(ngx_pool_t *pool)
 {
-    ngx_pool_t        *p;
+    ngx_pool_data_t   *p;
     ngx_pool_large_t  *l;
 
     for (l = pool->large; l; l = l->next) {
@@ -108,12 +105,16 @@
         }
     }
 
-    for (p = pool; p; p = p->d.next) {
-        p->d.last = (u_char *) p + sizeof(ngx_pool_t);
-        p->d.failed = 0;
+    for (p = &pool->d; p; p = p->next) {
+        if (p == &pool->d) {
+            p->last = (u_char *) p + sizeof(ngx_pool_t);
+        } else {
+            p->last = (u_char *) p + sizeof(ngx_pool_data_t);
+        }
+        p->failed = 0;
     }
 
-    pool->current = pool;
+    pool->current = &pool->d;
     pool->chain = NULL;
     pool->large = NULL;
 }
@@ -148,25 +149,25 @@
 static ngx_inline void *
 ngx_palloc_small(ngx_pool_t *pool, size_t size, ngx_uint_t align)
 {
-    u_char      *m;
-    ngx_pool_t  *p;
+    u_char           *m;
+    ngx_pool_data_t  *p;
 
     p = pool->current;
 
     do {
-        m = p->d.last;
+        m = p->last;
 
         if (align) {
             m = ngx_align_ptr(m, NGX_ALIGNMENT);
         }
 
-        if ((size_t) (p->d.end - m) >= size) {
-            p->d.last = m + size;
+        if ((size_t) (p->end - m) >= size) {
+            p->last = m + size;
 
             return m;
         }
 
-        p = p->d.next;
+        p = p->next;
 
     } while (p);
 
@@ -177,9 +178,9 @@
 static void *
 ngx_palloc_block(ngx_pool_t *pool, size_t size)
 {
-    u_char      *m;
-    size_t       psize;
-    ngx_pool_t  *p, *new;
+    u_char           *m;
+    size_t            psize;
+    ngx_pool_data_t  *p, *new;
 
     psize = (size_t) (pool->d.end - (u_char *) pool);
 
@@ -188,23 +189,23 @@
         return NULL;
     }
 
-    new = (ngx_pool_t *) m;
+    new = (ngx_pool_data_t *) m;
 
-    new->d.end = m + psize;
-    new->d.next = NULL;
-    new->d.failed = 0;
+    new->end = m + psize;
+    new->next = NULL;
+    new->failed = 0;
 
     m += sizeof(ngx_pool_data_t);
     m = ngx_align_ptr(m, NGX_ALIGNMENT);
-    new->d.last = m + size;
+    new->last = m + size;
 
-    for (p = pool->current; p->d.next; p = p->d.next) {
-        if (p->d.failed++ > 4) {
-            pool->current = p->d.next;
+    for (p = pool->current; p->next; p = p->next) {
+        if (p->failed++ > 4) {
+            pool->current = p->next;
         }
     }
 
-    p->d.next = new;
+    p->next = new;
 
     return m;
 }
diff -r d964b0aee8e7 -r 9950434a898d src/core/ngx_palloc.h
--- a/src/core/ngx_palloc.h	Thu May 23 16:49:22 2019 +0300
+++ b/src/core/ngx_palloc.h	Tue Jun 04 16:23:44 2019 +0800
@@ -46,18 +46,20 @@
 };
 
 
-typedef struct {
+typedef struct ngx_pool_data_s  ngx_pool_data_t;
+
+struct ngx_pool_data_s {
     u_char               *last;
     u_char               *end;
-    ngx_pool_t           *next;
+    ngx_pool_data_t      *next;
     ngx_uint_t            failed;
-} ngx_pool_data_t;
+};
 
 
 struct ngx_pool_s {
     ngx_pool_data_t       d;
     size_t                max;
-    ngx_pool_t           *current;
+    ngx_pool_data_t      *current;
     ngx_chain_t          *chain;
     ngx_pool_large_t     *large;
     ngx_pool_cleanup_t   *cleanup;