1e18a033bSKonstantin Ananyev
2e18a033bSKonstantin Ananyev/*
3e18a033bSKonstantin Ananyev * Copyright (C) Igor Sysoev
4e18a033bSKonstantin Ananyev * Copyright (C) Nginx, Inc.
5e18a033bSKonstantin Ananyev */
6e18a033bSKonstantin Ananyev
7e18a033bSKonstantin Ananyev
8e18a033bSKonstantin Ananyev#include <ngx_config.h>
9e18a033bSKonstantin Ananyev#include <ngx_core.h>
10e18a033bSKonstantin Ananyev
11e18a033bSKonstantin Ananyev
12e18a033bSKonstantin Ananyevstatic ngx_inline void *ngx_palloc_small(ngx_pool_t *pool, size_t size,
13e18a033bSKonstantin Ananyev    ngx_uint_t align);
14e18a033bSKonstantin Ananyevstatic void *ngx_palloc_block(ngx_pool_t *pool, size_t size);
15e18a033bSKonstantin Ananyevstatic void *ngx_palloc_large(ngx_pool_t *pool, size_t size);
16e18a033bSKonstantin Ananyev
17e18a033bSKonstantin Ananyev
18e18a033bSKonstantin Ananyevngx_pool_t *
19e18a033bSKonstantin Ananyevngx_create_pool(size_t size, ngx_log_t *log)
20e18a033bSKonstantin Ananyev{
21e18a033bSKonstantin Ananyev    ngx_pool_t  *p;
22e18a033bSKonstantin Ananyev
23e18a033bSKonstantin Ananyev    p = ngx_memalign(NGX_POOL_ALIGNMENT, size, log);
24e18a033bSKonstantin Ananyev    if (p == NULL) {
25e18a033bSKonstantin Ananyev        return NULL;
26e18a033bSKonstantin Ananyev    }
27e18a033bSKonstantin Ananyev
28e18a033bSKonstantin Ananyev    p->d.last = (u_char *) p + sizeof(ngx_pool_t);
29e18a033bSKonstantin Ananyev    p->d.end = (u_char *) p + size;
30e18a033bSKonstantin Ananyev    p->d.next = NULL;
31e18a033bSKonstantin Ananyev    p->d.failed = 0;
32e18a033bSKonstantin Ananyev
33e18a033bSKonstantin Ananyev    size = size - sizeof(ngx_pool_t);
34e18a033bSKonstantin Ananyev    p->max = (size < NGX_MAX_ALLOC_FROM_POOL) ? size : NGX_MAX_ALLOC_FROM_POOL;
35e18a033bSKonstantin Ananyev
36e18a033bSKonstantin Ananyev    p->current = p;
37e18a033bSKonstantin Ananyev    p->chain = NULL;
38e18a033bSKonstantin Ananyev    p->large = NULL;
39e18a033bSKonstantin Ananyev    p->cleanup = NULL;
40e18a033bSKonstantin Ananyev    p->log = log;
41e18a033bSKonstantin Ananyev
42e18a033bSKonstantin Ananyev    return p;
43e18a033bSKonstantin Ananyev}
44e18a033bSKonstantin Ananyev
45e18a033bSKonstantin Ananyev
46e18a033bSKonstantin Ananyevvoid
47e18a033bSKonstantin Ananyevngx_destroy_pool(ngx_pool_t *pool)
48e18a033bSKonstantin Ananyev{
49e18a033bSKonstantin Ananyev    ngx_pool_t          *p, *n;
50e18a033bSKonstantin Ananyev    ngx_pool_large_t    *l;
51e18a033bSKonstantin Ananyev    ngx_pool_cleanup_t  *c;
52e18a033bSKonstantin Ananyev
53e18a033bSKonstantin Ananyev    for (c = pool->cleanup; c; c = c->next) {
54e18a033bSKonstantin Ananyev        if (c->handler) {
55e18a033bSKonstantin Ananyev            ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
56e18a033bSKonstantin Ananyev                           "run cleanup: %p", c);
57e18a033bSKonstantin Ananyev            c->handler(c->data);
58e18a033bSKonstantin Ananyev        }
59e18a033bSKonstantin Ananyev    }
60e18a033bSKonstantin Ananyev
61e18a033bSKonstantin Ananyev#if (NGX_DEBUG)
62e18a033bSKonstantin Ananyev
63e18a033bSKonstantin Ananyev    /*
64e18a033bSKonstantin Ananyev     * we could allocate the pool->log from this pool
65e18a033bSKonstantin Ananyev     * so we cannot use this log while free()ing the pool
66e18a033bSKonstantin Ananyev     */
67e18a033bSKonstantin Ananyev
68e18a033bSKonstantin Ananyev    for (l = pool->large; l; l = l->next) {
69e18a033bSKonstantin Ananyev        ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0, "free: %p", l->alloc);
70e18a033bSKonstantin Ananyev    }
71e18a033bSKonstantin Ananyev
72e18a033bSKonstantin Ananyev    for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
73e18a033bSKonstantin Ananyev        ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
74e18a033bSKonstantin Ananyev                       "free: %p, unused: %uz", p, p->d.end - p->d.last);
75e18a033bSKonstantin Ananyev
76e18a033bSKonstantin Ananyev        if (n == NULL) {
77e18a033bSKonstantin Ananyev            break;
78e18a033bSKonstantin Ananyev        }
79e18a033bSKonstantin Ananyev    }
80e18a033bSKonstantin Ananyev
81e18a033bSKonstantin Ananyev#endif
82e18a033bSKonstantin Ananyev
83e18a033bSKonstantin Ananyev    for (l = pool->large; l; l = l->next) {
84e18a033bSKonstantin Ananyev        if (l->alloc) {
85e18a033bSKonstantin Ananyev            ngx_free(l->alloc);
86e18a033bSKonstantin Ananyev        }
87e18a033bSKonstantin Ananyev    }
88e18a033bSKonstantin Ananyev
89e18a033bSKonstantin Ananyev    for (p = pool, n = pool->d.next; /* void */; p = n, n = n->d.next) {
90e18a033bSKonstantin Ananyev        ngx_free(p);
91e18a033bSKonstantin Ananyev
92e18a033bSKonstantin Ananyev        if (n == NULL) {
93e18a033bSKonstantin Ananyev            break;
94e18a033bSKonstantin Ananyev        }
95e18a033bSKonstantin Ananyev    }
96e18a033bSKonstantin Ananyev}
97e18a033bSKonstantin Ananyev
98e18a033bSKonstantin Ananyev
99e18a033bSKonstantin Ananyevvoid
100e18a033bSKonstantin Ananyevngx_reset_pool(ngx_pool_t *pool)
101e18a033bSKonstantin Ananyev{
102e18a033bSKonstantin Ananyev    ngx_pool_t        *p;
103e18a033bSKonstantin Ananyev    ngx_pool_large_t  *l;
104e18a033bSKonstantin Ananyev
105e18a033bSKonstantin Ananyev    for (l = pool->large; l; l = l->next) {
106e18a033bSKonstantin Ananyev        if (l->alloc) {
107e18a033bSKonstantin Ananyev            ngx_free(l->alloc);
108e18a033bSKonstantin Ananyev        }
109e18a033bSKonstantin Ananyev    }
110e18a033bSKonstantin Ananyev
111e18a033bSKonstantin Ananyev    for (p = pool; p; p = p->d.next) {
112e18a033bSKonstantin Ananyev        p->d.last = (u_char *) p + sizeof(ngx_pool_t);
113e18a033bSKonstantin Ananyev        p->d.failed = 0;
114e18a033bSKonstantin Ananyev    }
115e18a033bSKonstantin Ananyev
116e18a033bSKonstantin Ananyev    pool->current = pool;
117e18a033bSKonstantin Ananyev    pool->chain = NULL;
118e18a033bSKonstantin Ananyev    pool->large = NULL;
119e18a033bSKonstantin Ananyev}
120e18a033bSKonstantin Ananyev
121e18a033bSKonstantin Ananyev
122e18a033bSKonstantin Ananyevvoid *
123e18a033bSKonstantin Ananyevngx_palloc(ngx_pool_t *pool, size_t size)
124e18a033bSKonstantin Ananyev{
125e18a033bSKonstantin Ananyev#if !(NGX_DEBUG_PALLOC)
126e18a033bSKonstantin Ananyev    if (size <= pool->max) {
127e18a033bSKonstantin Ananyev        return ngx_palloc_small(pool, size, 1);
128e18a033bSKonstantin Ananyev    }
129e18a033bSKonstantin Ananyev#endif
130e18a033bSKonstantin Ananyev
131e18a033bSKonstantin Ananyev    return ngx_palloc_large(pool, size);
132e18a033bSKonstantin Ananyev}
133e18a033bSKonstantin Ananyev
134e18a033bSKonstantin Ananyev
135e18a033bSKonstantin Ananyevvoid *
136e18a033bSKonstantin Ananyevngx_pnalloc(ngx_pool_t *pool, size_t size)
137e18a033bSKonstantin Ananyev{
138e18a033bSKonstantin Ananyev#if !(NGX_DEBUG_PALLOC)
139e18a033bSKonstantin Ananyev    if (size <= pool->max) {
140e18a033bSKonstantin Ananyev        return ngx_palloc_small(pool, size, 0);
141e18a033bSKonstantin Ananyev    }
142e18a033bSKonstantin Ananyev#endif
143e18a033bSKonstantin Ananyev
144e18a033bSKonstantin Ananyev    return ngx_palloc_large(pool, size);
145e18a033bSKonstantin Ananyev}
146e18a033bSKonstantin Ananyev
147e18a033bSKonstantin Ananyev
148e18a033bSKonstantin Ananyevstatic ngx_inline void *
149e18a033bSKonstantin Ananyevngx_palloc_small(ngx_pool_t *pool, size_t size, ngx_uint_t align)
150e18a033bSKonstantin Ananyev{
151e18a033bSKonstantin Ananyev    u_char      *m;
152e18a033bSKonstantin Ananyev    ngx_pool_t  *p;
153e18a033bSKonstantin Ananyev
154e18a033bSKonstantin Ananyev    p = pool->current;
155e18a033bSKonstantin Ananyev
156e18a033bSKonstantin Ananyev    do {
157e18a033bSKonstantin Ananyev        m = p->d.last;
158e18a033bSKonstantin Ananyev
159e18a033bSKonstantin Ananyev        if (align) {
160e18a033bSKonstantin Ananyev            m = ngx_align_ptr(m, NGX_ALIGNMENT);
161e18a033bSKonstantin Ananyev        }
162e18a033bSKonstantin Ananyev
163e18a033bSKonstantin Ananyev        if ((size_t) (p->d.end - m) >= size) {
164e18a033bSKonstantin Ananyev            p->d.last = m + size;
165e18a033bSKonstantin Ananyev
166e18a033bSKonstantin Ananyev            return m;
167e18a033bSKonstantin Ananyev        }
168e18a033bSKonstantin Ananyev
169e18a033bSKonstantin Ananyev        p = p->d.next;
170e18a033bSKonstantin Ananyev
171e18a033bSKonstantin Ananyev    } while (p);
172e18a033bSKonstantin Ananyev
173e18a033bSKonstantin Ananyev    return ngx_palloc_block(pool, size);
174e18a033bSKonstantin Ananyev}
175e18a033bSKonstantin Ananyev
176e18a033bSKonstantin Ananyev
177e18a033bSKonstantin Ananyevstatic void *
178e18a033bSKonstantin Ananyevngx_palloc_block(ngx_pool_t *pool, size_t size)
179e18a033bSKonstantin Ananyev{
180e18a033bSKonstantin Ananyev    u_char      *m;
181e18a033bSKonstantin Ananyev    size_t       psize;
182e18a033bSKonstantin Ananyev    ngx_pool_t  *p, *new;
183e18a033bSKonstantin Ananyev
184e18a033bSKonstantin Ananyev    psize = (size_t) (pool->d.end - (u_char *) pool);
185e18a033bSKonstantin Ananyev
186e18a033bSKonstantin Ananyev    m = ngx_memalign(NGX_POOL_ALIGNMENT, psize, pool->log);
187e18a033bSKonstantin Ananyev    if (m == NULL) {
188e18a033bSKonstantin Ananyev        return NULL;
189e18a033bSKonstantin Ananyev    }
190e18a033bSKonstantin Ananyev
191e18a033bSKonstantin Ananyev    new = (ngx_pool_t *) m;
192e18a033bSKonstantin Ananyev
193e18a033bSKonstantin Ananyev    new->d.end = m + psize;
194e18a033bSKonstantin Ananyev    new->d.next = NULL;
195e18a033bSKonstantin Ananyev    new->d.failed = 0;
196e18a033bSKonstantin Ananyev
197e18a033bSKonstantin Ananyev    m += sizeof(ngx_pool_data_t);
198e18a033bSKonstantin Ananyev    m = ngx_align_ptr(m, NGX_ALIGNMENT);
199e18a033bSKonstantin Ananyev    new->d.last = m + size;
200e18a033bSKonstantin Ananyev
201e18a033bSKonstantin Ananyev    for (p = pool->current; p->d.next; p = p->d.next) {
202e18a033bSKonstantin Ananyev        if (p->d.failed++ > 4) {
203e18a033bSKonstantin Ananyev            pool->current = p->d.next;
204e18a033bSKonstantin Ananyev        }
205e18a033bSKonstantin Ananyev    }
206e18a033bSKonstantin Ananyev
207e18a033bSKonstantin Ananyev    p->d.next = new;
208e18a033bSKonstantin Ananyev
209e18a033bSKonstantin Ananyev    return m;
210e18a033bSKonstantin Ananyev}
211e18a033bSKonstantin Ananyev
212e18a033bSKonstantin Ananyev
213e18a033bSKonstantin Ananyevstatic void *
214e18a033bSKonstantin Ananyevngx_palloc_large(ngx_pool_t *pool, size_t size)
215e18a033bSKonstantin Ananyev{
216e18a033bSKonstantin Ananyev    void              *p;
217e18a033bSKonstantin Ananyev    ngx_uint_t         n;
218e18a033bSKonstantin Ananyev    ngx_pool_large_t  *large;
219e18a033bSKonstantin Ananyev
220e18a033bSKonstantin Ananyev    p = ngx_alloc(size, pool->log);
221e18a033bSKonstantin Ananyev    if (p == NULL) {
222e18a033bSKonstantin Ananyev        return NULL;
223e18a033bSKonstantin Ananyev    }
224e18a033bSKonstantin Ananyev
225e18a033bSKonstantin Ananyev    n = 0;
226e18a033bSKonstantin Ananyev
227e18a033bSKonstantin Ananyev    for (large = pool->large; large; large = large->next) {
228e18a033bSKonstantin Ananyev        if (large->alloc == NULL) {
229e18a033bSKonstantin Ananyev            large->alloc = p;
230e18a033bSKonstantin Ananyev            return p;
231e18a033bSKonstantin Ananyev        }
232e18a033bSKonstantin Ananyev
233e18a033bSKonstantin Ananyev        if (n++ > 3) {
234e18a033bSKonstantin Ananyev            break;
235e18a033bSKonstantin Ananyev        }
236e18a033bSKonstantin Ananyev    }
237e18a033bSKonstantin Ananyev
238e18a033bSKonstantin Ananyev    large = ngx_palloc_small(pool, sizeof(ngx_pool_large_t), 1);
239e18a033bSKonstantin Ananyev    if (large == NULL) {
240e18a033bSKonstantin Ananyev        ngx_free(p);
241e18a033bSKonstantin Ananyev        return NULL;
242e18a033bSKonstantin Ananyev    }
243e18a033bSKonstantin Ananyev
244e18a033bSKonstantin Ananyev    large->alloc = p;
245e18a033bSKonstantin Ananyev    large->next = pool->large;
246e18a033bSKonstantin Ananyev    pool->large = large;
247e18a033bSKonstantin Ananyev
248e18a033bSKonstantin Ananyev    return p;
249e18a033bSKonstantin Ananyev}
250e18a033bSKonstantin Ananyev
251e18a033bSKonstantin Ananyev
252e18a033bSKonstantin Ananyevvoid *
253e18a033bSKonstantin Ananyevngx_pmemalign(ngx_pool_t *pool, size_t size, size_t alignment)
254e18a033bSKonstantin Ananyev{
255e18a033bSKonstantin Ananyev    void              *p;
256e18a033bSKonstantin Ananyev    ngx_pool_large_t  *large;
257e18a033bSKonstantin Ananyev
258e18a033bSKonstantin Ananyev    p = ngx_memalign(alignment, size, pool->log);
259e18a033bSKonstantin Ananyev    if (p == NULL) {
260e18a033bSKonstantin Ananyev        return NULL;
261e18a033bSKonstantin Ananyev    }
262e18a033bSKonstantin Ananyev
263e18a033bSKonstantin Ananyev    large = ngx_palloc_small(pool, sizeof(ngx_pool_large_t), 1);
264e18a033bSKonstantin Ananyev    if (large == NULL) {
265e18a033bSKonstantin Ananyev        ngx_free(p);
266e18a033bSKonstantin Ananyev        return NULL;
267e18a033bSKonstantin Ananyev    }
268e18a033bSKonstantin Ananyev
269e18a033bSKonstantin Ananyev    large->alloc = p;
270e18a033bSKonstantin Ananyev    large->next = pool->large;
271e18a033bSKonstantin Ananyev    pool->large = large;
272e18a033bSKonstantin Ananyev
273e18a033bSKonstantin Ananyev    return p;
274e18a033bSKonstantin Ananyev}
275e18a033bSKonstantin Ananyev
276e18a033bSKonstantin Ananyev
277e18a033bSKonstantin Ananyevngx_int_t
278e18a033bSKonstantin Ananyevngx_pfree(ngx_pool_t *pool, void *p)
279e18a033bSKonstantin Ananyev{
280e18a033bSKonstantin Ananyev    ngx_pool_large_t  *l;
281e18a033bSKonstantin Ananyev
282e18a033bSKonstantin Ananyev    for (l = pool->large; l; l = l->next) {
283e18a033bSKonstantin Ananyev        if (p == l->alloc) {
284e18a033bSKonstantin Ananyev            ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, pool->log, 0,
285e18a033bSKonstantin Ananyev                           "free: %p", l->alloc);
286e18a033bSKonstantin Ananyev            ngx_free(l->alloc);
287e18a033bSKonstantin Ananyev            l->alloc = NULL;
288e18a033bSKonstantin Ananyev
289e18a033bSKonstantin Ananyev            return NGX_OK;
290e18a033bSKonstantin Ananyev        }
291e18a033bSKonstantin Ananyev    }
292e18a033bSKonstantin Ananyev
293e18a033bSKonstantin Ananyev    return NGX_DECLINED;
294e18a033bSKonstantin Ananyev}
295e18a033bSKonstantin Ananyev
296e18a033bSKonstantin Ananyev
297e18a033bSKonstantin Ananyevvoid *
298e18a033bSKonstantin Ananyevngx_pcalloc(ngx_pool_t *pool, size_t size)
299e18a033bSKonstantin Ananyev{
300e18a033bSKonstantin Ananyev    void *p;
301e18a033bSKonstantin Ananyev
302e18a033bSKonstantin Ananyev    p = ngx_palloc(pool, size);
303e18a033bSKonstantin Ananyev    if (p) {
304e18a033bSKonstantin Ananyev        ngx_memzero(p, size);
305e18a033bSKonstantin Ananyev    }
306e18a033bSKonstantin Ananyev
307e18a033bSKonstantin Ananyev    return p;
308e18a033bSKonstantin Ananyev}
309e18a033bSKonstantin Ananyev
310e18a033bSKonstantin Ananyev
311e18a033bSKonstantin Ananyevngx_pool_cleanup_t *
312e18a033bSKonstantin Ananyevngx_pool_cleanup_add(ngx_pool_t *p, size_t size)
313e18a033bSKonstantin Ananyev{
314e18a033bSKonstantin Ananyev    ngx_pool_cleanup_t  *c;
315e18a033bSKonstantin Ananyev
316e18a033bSKonstantin Ananyev    c = ngx_palloc(p, sizeof(ngx_pool_cleanup_t));
317e18a033bSKonstantin Ananyev    if (c == NULL) {
318e18a033bSKonstantin Ananyev        return NULL;
319e18a033bSKonstantin Ananyev    }
320e18a033bSKonstantin Ananyev
321e18a033bSKonstantin Ananyev    if (size) {
322e18a033bSKonstantin Ananyev        c->data = ngx_palloc(p, size);
323e18a033bSKonstantin Ananyev        if (c->data == NULL) {
324e18a033bSKonstantin Ananyev            return NULL;
325e18a033bSKonstantin Ananyev        }
326e18a033bSKonstantin Ananyev
327e18a033bSKonstantin Ananyev    } else {
328e18a033bSKonstantin Ananyev        c->data = NULL;
329e18a033bSKonstantin Ananyev    }
330e18a033bSKonstantin Ananyev
331e18a033bSKonstantin Ananyev    c->handler = NULL;
332e18a033bSKonstantin Ananyev    c->next = p->cleanup;
333e18a033bSKonstantin Ananyev
334e18a033bSKonstantin Ananyev    p->cleanup = c;
335e18a033bSKonstantin Ananyev
336e18a033bSKonstantin Ananyev    ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, p->log, 0, "add cleanup: %p", c);
337e18a033bSKonstantin Ananyev
338e18a033bSKonstantin Ananyev    return c;
339e18a033bSKonstantin Ananyev}
340e18a033bSKonstantin Ananyev
341e18a033bSKonstantin Ananyev
342e18a033bSKonstantin Ananyevvoid
343e18a033bSKonstantin Ananyevngx_pool_run_cleanup_file(ngx_pool_t *p, ngx_fd_t fd)
344e18a033bSKonstantin Ananyev{
345e18a033bSKonstantin Ananyev    ngx_pool_cleanup_t       *c;
346e18a033bSKonstantin Ananyev    ngx_pool_cleanup_file_t  *cf;
347e18a033bSKonstantin Ananyev
348e18a033bSKonstantin Ananyev    for (c = p->cleanup; c; c = c->next) {
349e18a033bSKonstantin Ananyev        if (c->handler == ngx_pool_cleanup_file) {
350e18a033bSKonstantin Ananyev
351e18a033bSKonstantin Ananyev            cf = c->data;
352e18a033bSKonstantin Ananyev
353e18a033bSKonstantin Ananyev            if (cf->fd == fd) {
354e18a033bSKonstantin Ananyev                c->handler(cf);
355e18a033bSKonstantin Ananyev                c->handler = NULL;
356e18a033bSKonstantin Ananyev                return;
357e18a033bSKonstantin Ananyev            }
358e18a033bSKonstantin Ananyev        }
359e18a033bSKonstantin Ananyev    }
360e18a033bSKonstantin Ananyev}
361e18a033bSKonstantin Ananyev
362e18a033bSKonstantin Ananyev
363e18a033bSKonstantin Ananyevvoid
364e18a033bSKonstantin Ananyevngx_pool_cleanup_file(void *data)
365e18a033bSKonstantin Ananyev{
366e18a033bSKonstantin Ananyev    ngx_pool_cleanup_file_t  *c = data;
367e18a033bSKonstantin Ananyev
368e18a033bSKonstantin Ananyev    ngx_log_debug1(NGX_LOG_DEBUG_ALLOC, c->log, 0, "file cleanup: fd:%d",
369e18a033bSKonstantin Ananyev                   c->fd);
370e18a033bSKonstantin Ananyev
371e18a033bSKonstantin Ananyev    if (ngx_close_file(c->fd) == NGX_FILE_ERROR) {
372e18a033bSKonstantin Ananyev        ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
373e18a033bSKonstantin Ananyev                      ngx_close_file_n " \"%s\" failed", c->name);
374e18a033bSKonstantin Ananyev    }
375e18a033bSKonstantin Ananyev}
376e18a033bSKonstantin Ananyev
377e18a033bSKonstantin Ananyev
378e18a033bSKonstantin Ananyevvoid
379e18a033bSKonstantin Ananyevngx_pool_delete_file(void *data)
380e18a033bSKonstantin Ananyev{
381e18a033bSKonstantin Ananyev    ngx_pool_cleanup_file_t  *c = data;
382e18a033bSKonstantin Ananyev
383e18a033bSKonstantin Ananyev    ngx_err_t  err;
384e18a033bSKonstantin Ananyev
385e18a033bSKonstantin Ananyev    ngx_log_debug2(NGX_LOG_DEBUG_ALLOC, c->log, 0, "file cleanup: fd:%d %s",
386e18a033bSKonstantin Ananyev                   c->fd, c->name);
387e18a033bSKonstantin Ananyev
388e18a033bSKonstantin Ananyev    if (ngx_delete_file(c->name) == NGX_FILE_ERROR) {
389e18a033bSKonstantin Ananyev        err = ngx_errno;
390e18a033bSKonstantin Ananyev
391e18a033bSKonstantin Ananyev        if (err != NGX_ENOENT) {
392e18a033bSKonstantin Ananyev            ngx_log_error(NGX_LOG_CRIT, c->log, err,
393e18a033bSKonstantin Ananyev                          ngx_delete_file_n " \"%s\" failed", c->name);
394e18a033bSKonstantin Ananyev        }
395e18a033bSKonstantin Ananyev    }
396e18a033bSKonstantin Ananyev
397e18a033bSKonstantin Ananyev    if (ngx_close_file(c->fd) == NGX_FILE_ERROR) {
398e18a033bSKonstantin Ananyev        ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
399e18a033bSKonstantin Ananyev                      ngx_close_file_n " \"%s\" failed", c->name);
400e18a033bSKonstantin Ananyev    }
401e18a033bSKonstantin Ananyev}
402e18a033bSKonstantin Ananyev
403e18a033bSKonstantin Ananyev
404e18a033bSKonstantin Ananyev#if 0
405e18a033bSKonstantin Ananyev
406e18a033bSKonstantin Ananyevstatic void *
407e18a033bSKonstantin Ananyevngx_get_cached_block(size_t size)
408e18a033bSKonstantin Ananyev{
409e18a033bSKonstantin Ananyev    void                     *p;
410e18a033bSKonstantin Ananyev    ngx_cached_block_slot_t  *slot;
411e18a033bSKonstantin Ananyev
412e18a033bSKonstantin Ananyev    if (ngx_cycle->cache == NULL) {
413e18a033bSKonstantin Ananyev        return NULL;
414e18a033bSKonstantin Ananyev    }
415e18a033bSKonstantin Ananyev
416e18a033bSKonstantin Ananyev    slot = &ngx_cycle->cache[(size + ngx_pagesize - 1) / ngx_pagesize];
417e18a033bSKonstantin Ananyev
418e18a033bSKonstantin Ananyev    slot->tries++;
419e18a033bSKonstantin Ananyev
420e18a033bSKonstantin Ananyev    if (slot->number) {
421e18a033bSKonstantin Ananyev        p = slot->block;
422e18a033bSKonstantin Ananyev        slot->block = slot->block->next;
423