Mercurial > hg > nginx-vendor-current

comparison src/core/ngx_palloc.c @ 0:f0b350454894 NGINX_0_1_0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
nginx 0.1.0 *) The first public version.
author Igor Sysoev <http://sysoev.ru>
date Mon, 04 Oct 2004 00:00:00 +0400
parents
children cc9f381affaa
comparison
equal deleted inserted replaced
-1:000000000000 0:f0b350454894
1
2 /*
3 * Copyright (C) Igor Sysoev
4 */
5
6
7 #include <ngx_config.h>
8 #include <ngx_core.h>
9
10
11 ngx_pool_t *ngx_create_pool(size_t size, ngx_log_t *log)
12 {
13 ngx_pool_t *p;
14
15 if (!(p = ngx_alloc(size, log))) {
16 return NULL;
17 }
18
19 p->last = (char *) p + sizeof(ngx_pool_t);
20 p->end = (char *) p + size;
21 p->next = NULL;
22 p->large = NULL;
23 p->log = log;
24
25 return p;
26 }
27
28
29 void ngx_destroy_pool(ngx_pool_t *pool)
30 {
31 ngx_pool_t *p, *n;
32 ngx_pool_large_t *l;
33
34 for (l = pool->large; l; l = l->next) {
35
36 ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
37 "free: " PTR_FMT, l->alloc);
38
39 if (l->alloc) {
40 free(l->alloc);
41 }
42 }
43
44 #if (NGX_DEBUG)
45
46 /*
47 * we could allocate the pool->log from this pool
48 * so we can not use this log while the free()ing the pool
49 */
50
51 for (p = pool, n = pool->next; /* void */; p = n, n = n->next) {
52 ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
53 "free: " PTR_FMT ", unused: " SIZE_T_FMT,
54 p, p->end - p->last);
55
56 if (n == NULL) {
57 break;
58 }
59 }
60
61 #endif
62
63 for (p = pool, n = pool->next; /* void */; p = n, n = n->next) {
64 free(p);
65
66 if (n == NULL) {
67 break;
68 }
69 }
70 }
71
72
73 void *ngx_palloc(ngx_pool_t *pool, size_t size)
74 {
75 char *m;
76 ngx_pool_t *p, *n;
77 ngx_pool_large_t *large, *last;
78
79 if (size <= (size_t) NGX_MAX_ALLOC_FROM_POOL
80 && size <= (size_t) (pool->end - (char *) pool) - sizeof(ngx_pool_t))
81 {
82 for (p = pool, n = pool->next; /* void */; p = n, n = n->next) {
83 m = ngx_align(p->last);
84
85 if ((size_t) (p->end - m) >= size) {
86 p->last = m + size ;
87
88 return m;
89 }
90
91 if (n == NULL) {
92 break;
93 }
94 }
95
96 /* allocate a new pool block */
97
98 if (!(n = ngx_create_pool((size_t) (p->end - (char *) p), p->log))) {
99 return NULL;
100 }
101
102 p->next = n;
103 m = n->last;
104 n->last += size;
105
106 return m;
107 }
108
109 /* allocate a large block */
110
111 large = NULL;
112 last = NULL;
113
114 if (pool->large) {
115 for (last = pool->large; /* void */ ; last = last->next) {
116 if (last->alloc == NULL) {
117 large = last;
118 last = NULL;
119 break;
120 }
121
122 if (last->next == NULL) {
123 break;
124 }
125 }
126 }
127
128 if (large == NULL) {
129 if (!(large = ngx_palloc(pool, sizeof(ngx_pool_large_t)))) {
130 return NULL;
131 }
132
133 large->next = NULL;
134 }
135
136 #if 0
137 if (!(p = ngx_memalign(ngx_pagesize, size, pool->log))) {
138 return NULL;
139 }
140 #else
141 if (!(p = ngx_alloc(size, pool->log))) {
142 return NULL;
143 }
144 #endif
145
146 if (pool->large == NULL) {
147 pool->large = large;
148
149 } else if (last) {
150 last->next = large;
151 }
152
153 large->alloc = p;
154
155 return p;
156 }
157
158
159 ngx_int_t ngx_pfree(ngx_pool_t *pool, void *p)
160 {
161 ngx_pool_large_t *l;
162
163 for (l = pool->large; l; l = l->next) {
164 if (p == l->alloc) {
165 ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
166 "free: " PTR_FMT, l->alloc);
167 free(l->alloc);
168 l->alloc = NULL;
169
170 return NGX_OK;
171 }
172 }
173
174 return NGX_DECLINED;
175 }
176
177
178 void *ngx_pcalloc(ngx_pool_t *pool, size_t size)
179 {
180 void *p;
181
182 p = ngx_palloc(pool, size);
183 if (p) {
184 ngx_memzero(p, size);
185 }
186
187 return p;
188 }
189
190 #if 0
191
192 static void *ngx_get_cached_block(size_t size)
193 {
194 void *p;
195 ngx_cached_block_slot_t *slot;
196
197 if (ngx_cycle->cache == NULL) {
198 return NULL;
199 }
200
201 slot = &ngx_cycle->cache[(size + ngx_pagesize - 1) / ngx_pagesize];
202
203 slot->tries++;
204
205 if (slot->number) {
206 p = slot->block;
207 slot->block = slot->block->next;
208 slot->number--;
209 return p;
210 }
211
212 return NULL;
213 }
214
215 #endif