Mercurial > hg > nginx-vendor-0-7
comparison src/core/ngx_palloc.c @ 0:f0b350454894 NGINX_0_1_0
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 |