Mercurial > hg > nginx-ranges

comparison src/core/ngx_palloc.c @ 382:984bb0b1399b NGINX_0_7_3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
nginx 0.7.3 *) Change: the "rss" extension MIME type has been changed to "application/rss+xml". *) Change: now the "gzip_vary" directive turned on issues a "Vary: Accept-Encoding" header line for uncompressed responses too. *) Feature: now the "rewrite" directive does a redirect automatically if the "https://" protocol is used. *) Bugfix: the "proxy_pass" directive did not work with the HTTPS protocol; the bug had appeared in 0.6.9.
author Igor Sysoev <http://sysoev.ru>
date Mon, 23 Jun 2008 00:00:00 +0400
parents bc21d9cd9c54
children 0b6053502c55
comparison
equal deleted inserted replaced
381:23d1555141d9 382:984bb0b1399b
6 6
7 #include <ngx_config.h> 7 #include <ngx_config.h>
8 #include <ngx_core.h> 8 #include <ngx_core.h>
9 9
10 10
11 static void *ngx_palloc_block(ngx_pool_t *pool, size_t size);
12 static void *ngx_palloc_large(ngx_pool_t *pool, size_t size);
13
14
11 ngx_pool_t * 15 ngx_pool_t *
12 ngx_create_pool(size_t size, ngx_log_t *log) 16 ngx_create_pool(size_t size, ngx_log_t *log)
13 { 17 {
14 ngx_pool_t *p; 18 ngx_pool_t *p;
15 19
16 p = ngx_alloc(size, log); 20 p = ngx_alloc(size, log);
17 if (p == NULL) { 21 if (p == NULL) {
18 return NULL; 22 return NULL;
19 } 23 }
20 24
21 p->last = (u_char *) p + sizeof(ngx_pool_t); 25 p->d.last = (u_char *) p + sizeof(ngx_pool_t);
22 p->end = (u_char *) p + size; 26 p->d.end = (u_char *) p + size;
27 p->d.next = NULL;
28
29 size = size - sizeof(ngx_pool_t);
30 p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL;
31
23 p->current = p; 32 p->current = p;
24 p->chain = NULL; 33 p->chain = NULL;
25 p->next = NULL;
26 p->large = NULL; 34 p->large = NULL;
27 p->cleanup = NULL; 35 p->cleanup = NULL;
28 p->log = log; 36 p->log = log;
29 37
30 return p; 38 return p;
60 /* 68 /*
61 * we could allocate the pool->log from this pool 69 * we could allocate the pool->log from this pool
62 * so we can not use this log while the free()ing the pool 70 * so we can not use this log while the free()ing the pool
63 */ 71 */
64 72
65 for (p = pool, n = pool->next; /* void */; p = n, n = n->next) { 73 for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
66 ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, pool->log, 0, 74 ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
67 "free: %p, unused: %uz", p, p->end - p->last); 75 "free: %p, unused: %uz", p, p->d.end - p->d.last);
68 76
69 if (n == NULL) { 77 if (n == NULL) {
70 break; 78 break;
71 } 79 }
72 } 80 }
73 81
74 #endif 82 #endif
75 83
76 for (p = pool, n = pool->next; /* void */; p = n, n = n->next) { 84 for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
77 ngx_free(p); 85 ngx_free(p);
78 86
79 if (n == NULL) { 87 if (n == NULL) {
80 break; 88 break;
81 } 89 }
84 92
85 93
86 void * 94 void *
87 ngx_palloc(ngx_pool_t *pool, size_t size) 95 ngx_palloc(ngx_pool_t *pool, size_t size)
88 { 96 {
89 u_char *m; 97 u_char *m;
90 ngx_pool_t *p, *n, *current; 98 ngx_pool_t *p;
91 ngx_pool_large_t *large; 99
92 100 if (size <= pool->max) {
93 if (size <= (size_t) NGX_MAX_ALLOC_FROM_POOL 101
94 && size <= (size_t) (pool->end - (u_char *) pool)
95 - (size_t) ngx_align_ptr(sizeof(ngx_pool_t), NGX_ALIGNMENT))
96 {
97 p = pool->current; 102 p = pool->current;
98 current = p; 103
99 104 do {
100 for ( ;; ) { 105 m = ngx_align_ptr(p->d.last, NGX_ALIGNMENT);
101 106
102 /* 107 if ((size_t) (p->d.end - m) >= size) {
103 * allow non-aligned memory blocks for small allocations (1, 2, 108 p->d.last = m + size;
104 * or 3 bytes) and for odd length strings (struct's have aligned
105 * size)
106 */
107
108 if (size < sizeof(int) || (size & 1)) {
109 m = p->last;
110
111 } else {
112 m = ngx_align_ptr(p->last, NGX_ALIGNMENT);
113 }
114
115 if ((size_t) (p->end - m) >= size) {
116 p->last = m + size;
117 109
118 return m; 110 return m;
119 } 111 }
120 112
121 if ((size_t) (p->end - m) < NGX_ALIGNMENT) { 113 p = p->d.next;
122 current = p->next; 114
115 } while (p);
116
117 return ngx_palloc_block(pool, size);
118 }
119
120 return ngx_palloc_large(pool, size);
121 }
122
123
124 void *
125 ngx_pnalloc(ngx_pool_t *pool, size_t size)
126 {
127 u_char *m;
128 ngx_pool_t *p;
129
130 if (size <= pool->max) {
131
132 p = pool->current;
133
134 do {
135 m = p->d.last;
136
137 if ((size_t) (p->d.end - m) >= size) {
138 p->d.last = m + size;
139
140 return m;
123 } 141 }
124 142
125 if (p->next == NULL) { 143 p = p->d.next;
126 break; 144
127 } 145 } while (p);
128 146
129 p = p->next; 147 return ngx_palloc_block(pool, size);
130 pool->current = current; 148 }
131 } 149
132 150 return ngx_palloc_large(pool, size);
133 /* allocate a new pool block */ 151 }
134 152
135 n = ngx_create_pool((size_t) (p->end - (u_char *) p), p->log); 153
136 if (n == NULL) { 154 static void *
137 return NULL; 155 ngx_palloc_block(ngx_pool_t *pool, size_t size)
138 } 156 {
139 157 u_char *m;
140 pool->current = current ? current : n; 158 size_t psize;
141 159 ngx_pool_t *p, *new, *current;
142 p->next = n; 160
143 m = ngx_align_ptr(n->last, NGX_ALIGNMENT); 161 psize = (size_t) (pool->d.end - (u_char *) pool);
144 n->last = m + size; 162
145 163 m = ngx_alloc(psize, pool->log);
146 return m; 164 if (m == NULL) {
147 } 165 return NULL;
166 }
167
168 new = (ngx_pool_t *) m;
169
170 new->d.end = m + psize;
171 new->d.next = NULL;
172
173 m += sizeof(ngx_pool_data_t);
174 new->d.last = m + size;
175
176 current = pool->current;
177
178 for (p = current; p->d.next; p = p->d.next) {
179 if ((size_t) (p->d.end - p->d.last) < NGX_ALIGNMENT) {
180 current = p->d.next;
181 }
182 }
183
184 p->d.next = new;
185
186 pool->current = current ? current : new;
187
188 return m;
189 }
190
191
192 static void *
193 ngx_palloc_large(ngx_pool_t *pool, size_t size)
194 {
195 void *p;
196 ngx_pool_large_t *large;
148 197
149 #if 0 198 #if 0
150 p = ngx_memalign(ngx_pagesize, size, pool->log); 199 p = ngx_memalign(ngx_pagesize, size, pool->log);
151 if (p == NULL) { 200 if (p == NULL) {
152 return NULL; 201 return NULL;
167 large->alloc = p; 216 large->alloc = p;
168 large->next = pool->large; 217 large->next = pool->large;
169 pool->large = large; 218 pool->large = large;
170 219
171 return p; 220 return p;
172 }
173
174
175 void *
176 ngx_palloc_aligned(ngx_pool_t *pool, size_t size)
177 {
178 if (size & 1) {
179 size++;
180 }
181
182 return ngx_palloc(pool, size);
183 } 221 }
184 222
185 223
186 ngx_int_t 224 ngx_int_t
187 ngx_pfree(ngx_pool_t *pool, void *p) 225 ngx_pfree(ngx_pool_t *pool, void *p)