GCOV - Varnish Cache


/*-
 * Copyright (c) 2011 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * Generic memory pool
 */

#include "config.h"

#include "cache_varnishd.h"

#include <stdio.h>
#include <stdlib.h>

#include "vtim.h"

#include "VSC_mempool.h"

struct memitem {
        unsigned                        magic;
#define MEMITEM_MAGIC                   0x42e55401
        unsigned                        size;
        VTAILQ_ENTRY(memitem)           list;
        vtim_real                       touched;        // XXX -> mono?
};

VTAILQ_HEAD(memhead_s, memitem);

struct mempool {
        unsigned                        magic;
#define MEMPOOL_MAGIC                   0x37a75a8d
        char                            name[12];
        struct memhead_s                list;
        struct memhead_s                surplus;
        struct lock                     mtx;
        volatile struct poolparam       *param;
        volatile unsigned               *cur_size;
        uint64_t                        live;
        struct vsc_seg                  *vsc_seg;
        struct VSC_mempool              *vsc;
        unsigned                        n_pool;
        pthread_t                       thread;
        vtim_real                       t_now;  // XXX -> mono?
        int                             self_destruct;
};

/*---------------------------------------------------------------------
 */

static struct memitem *
mpl_alloc(const struct mempool *mpl)
{
        unsigned tsz;
        struct memitem *mi;

        CHECK_OBJ_NOTNULL(mpl, MEMPOOL_MAGIC);
        tsz = *mpl->cur_size;
        mi = calloc(1, tsz);
        AN(mi);
        mi->magic = MEMITEM_MAGIC;
        mi->size = tsz;
        mpl->vsc->sz_wanted = tsz;
        mpl->vsc->sz_actual = tsz - sizeof *mi;
        return (mi);
}

/*---------------------------------------------------------------------
 * Pool-guard
 *   Attempt to keep number of free items in pool inside bounds with
 *   minimum locking activity, and keep an eye on items at the tail
 *   of the list not getting too old.
 */

static void *
mpl_guard(void *priv)
{
        struct mempool *mpl;
        struct memitem *mi = NULL;
        vtim_dur v_statevariable_(mpl_slp);
        vtim_real last = 0;

        CAST_OBJ_NOTNULL(mpl, priv, MEMPOOL_MAGIC);
        THR_SetName(mpl->name);
        THR_Init();
        mpl_slp = 0.15; // random
        while (1) {
                VTIM_sleep(mpl_slp);
                mpl_slp = 0.814;        // random
                mpl->t_now = VTIM_real();

                if (mi != NULL && (mpl->n_pool > mpl->param->max_pool ||
                    mi->size < *mpl->cur_size)) {
                        CHECK_OBJ(mi, MEMITEM_MAGIC);
                        FREE_OBJ(mi);
                }

                if (mi == NULL && mpl->n_pool < mpl->param->min_pool)
                        mi = mpl_alloc(mpl);

                if (mpl->n_pool < mpl->param->min_pool && mi != NULL) {
                        /* can do */
                } else if (mpl->n_pool > mpl->param->max_pool && mi == NULL) {
                        /* can do */
                } else if (!VTAILQ_EMPTY(&mpl->surplus)) {
                        /* can do */
                } else if (last + .1 * mpl->param->max_age < mpl->t_now) {
                        /* should do */
                } else if (mpl->self_destruct) {
                        /* can do */
                } else {
                        continue;       /* nothing to do */
                }

                mpl_slp = 0.314;        // random

                if (Lck_Trylock(&mpl->mtx))
                        continue;

                if (mpl->self_destruct) {
                        AZ(mpl->live);
                        while (1) {
                                if (mi == NULL) {
                                        mi = VTAILQ_FIRST(&mpl->list);
                                        if (mi != NULL) {
                                                mpl->vsc->pool = --mpl->n_pool;
                                                VTAILQ_REMOVE(&mpl->list,
                                                    mi, list);
                                        }
                                }
                                if (mi == NULL) {
                                        mi = VTAILQ_FIRST(&mpl->surplus);
                                        if (mi != NULL)
                                                VTAILQ_REMOVE(&mpl->surplus,
                                                    mi, list);
                                }
                                if (mi == NULL)
                                        break;
                                CHECK_OBJ(mi, MEMITEM_MAGIC);
                                FREE_OBJ(mi);
                        }
                        VSC_mempool_Destroy(&mpl->vsc_seg);
                        Lck_Unlock(&mpl->mtx);
                        Lck_Delete(&mpl->mtx);
                        FREE_OBJ(mpl);
                        break;
                }

                if (mpl->n_pool < mpl->param->min_pool &&
                    mi != NULL && mi->size >= *mpl->cur_size) {
                        CHECK_OBJ(mi, MEMITEM_MAGIC);
                        mpl->vsc->pool = ++mpl->n_pool;
                        mi->touched = mpl->t_now;
                        VTAILQ_INSERT_HEAD(&mpl->list, mi, list);
                        mi = NULL;
                        mpl_slp = .01;  // random

                }
                if (mpl->n_pool > mpl->param->max_pool && mi == NULL) {
                        mi = VTAILQ_FIRST(&mpl->list);
                        CHECK_OBJ_NOTNULL(mi, MEMITEM_MAGIC);
                        mpl->vsc->pool = --mpl->n_pool;
                        mpl->vsc->surplus++;
                        VTAILQ_REMOVE(&mpl->list, mi, list);
                        mpl_slp = .01;  // random
                }
                if (mi == NULL) {
                        mi = VTAILQ_FIRST(&mpl->surplus);
                        if (mi != NULL) {
                                CHECK_OBJ(mi, MEMITEM_MAGIC);
                                VTAILQ_REMOVE(&mpl->surplus, mi, list);
                                mpl_slp = .01;  // random
                        }
                }
                if (mi == NULL && mpl->n_pool > mpl->param->min_pool) {
                        mi = VTAILQ_LAST(&mpl->list, memhead_s);
                        CHECK_OBJ_NOTNULL(mi, MEMITEM_MAGIC);
                        if (mi->touched + mpl->param->max_age < mpl->t_now) {
                                mpl->vsc->pool = --mpl->n_pool;
                                mpl->vsc->timeout++;
                                VTAILQ_REMOVE(&mpl->list, mi, list);
                                mpl_slp = .01;  // random
                        } else {
                                mi = NULL;
                                last = mpl->t_now;
                        }
                } else if (mpl->n_pool <= mpl->param->min_pool) {
                        last = mpl->t_now;
                }

                Lck_Unlock(&mpl->mtx);

                if (mi != NULL) {
                        CHECK_OBJ(mi, MEMITEM_MAGIC);
                        FREE_OBJ(mi);
                }
        }
        return (NULL);
}

/*---------------------------------------------------------------------
 * Create a new memory pool, and start the guard thread for it.
 */

struct mempool *
MPL_New(const char *name,
    volatile struct poolparam *pp, volatile unsigned *cur_size)
{
        struct mempool *mpl;

        ALLOC_OBJ(mpl, MEMPOOL_MAGIC);
        AN(mpl);
        bprintf(mpl->name, "MPL_%s", name);
        mpl->param = pp;
        mpl->cur_size = cur_size;
        VTAILQ_INIT(&mpl->list);
        VTAILQ_INIT(&mpl->surplus);
        Lck_New(&mpl->mtx, lck_mempool);
        /* XXX: prealloc min_pool */
        mpl->vsc = VSC_mempool_New(NULL, &mpl->vsc_seg, mpl->name + 4);
        AN(mpl->vsc);
        PTOK(pthread_create(&mpl->thread, NULL, mpl_guard, mpl));
        PTOK(pthread_detach(mpl->thread));
        return (mpl);
}

/*---------------------------------------------------------------------
 * Destroy a memory pool.  There must be no live items, and we cheat
 * and leave all the hard work to the guard thread.
 */

void
MPL_Destroy(struct mempool **mpp)
{
        struct mempool *mpl;

        TAKE_OBJ_NOTNULL(mpl, mpp, MEMPOOL_MAGIC);
        Lck_Lock(&mpl->mtx);
        AZ(mpl->live);
        mpl->self_destruct = 1;
        Lck_Unlock(&mpl->mtx);
}

/*---------------------------------------------------------------------
 */

void *
MPL_Get(struct mempool *mpl, unsigned *size)
{
        struct memitem *mi;

        CHECK_OBJ_NOTNULL(mpl, MEMPOOL_MAGIC);
        AN(size);

        Lck_Lock(&mpl->mtx);

        mpl->vsc->allocs++;
        mpl->vsc->live = ++mpl->live;

        do {
                mi = VTAILQ_FIRST(&mpl->list);
                if (mi == NULL) {
                        mpl->vsc->randry++;
                        break;
                }
                mpl->vsc->pool = --mpl->n_pool;
                CHECK_OBJ(mi, MEMITEM_MAGIC);
                VTAILQ_REMOVE(&mpl->list, mi, list);
                if (mi->size < *mpl->cur_size) {
                        mpl->vsc->toosmall++;
                        VTAILQ_INSERT_HEAD(&mpl->surplus, mi, list);
                        mi = NULL;
                } else {
                        mpl->vsc->recycle++;
                }
        } while (mi == NULL);

        Lck_Unlock(&mpl->mtx);

        if (mi == NULL)
                mi = mpl_alloc(mpl);
        *size = mi->size - sizeof *mi;

        CHECK_OBJ(mi, MEMITEM_MAGIC);
        /* Throw away sizeof info for FlexeLint: */
        return ((void *)(uintptr_t)(mi + 1));
}

void
MPL_Free(struct mempool *mpl, void *item)
{
        struct memitem *mi;

        CHECK_OBJ_NOTNULL(mpl, MEMPOOL_MAGIC);
        AN(item);

        mi = (void*)((uintptr_t)item - sizeof(*mi));
        CHECK_OBJ_NOTNULL(mi, MEMITEM_MAGIC);
        memset(item, 0, mi->size - sizeof *mi);

        Lck_Lock(&mpl->mtx);

        mpl->vsc->frees++;
        mpl->vsc->live = --mpl->live;

        if (mi->size < *mpl->cur_size) {
                mpl->vsc->toosmall++;
                VTAILQ_INSERT_HEAD(&mpl->surplus, mi, list);
        } else {
                mpl->vsc->pool = ++mpl->n_pool;
                mi->touched = mpl->t_now;
                VTAILQ_INSERT_HEAD(&mpl->list, mi, list);
        }

        Lck_Unlock(&mpl->mtx);
}

void
MPL_AssertSane(const void *item)
{
        struct memitem *mi;
        mi = (void*)((uintptr_t)item - sizeof(*mi));
        CHECK_OBJ_NOTNULL(mi, MEMITEM_MAGIC);
}

		varnish-cache/bin/varnishd/cache/cache_mempool.c
0		/*-
1		* Copyright (c) 2011 Varnish Software AS
2		* All rights reserved.
3		*
4		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
5		*
6		* SPDX-License-Identifier: BSD-2-Clause
7		*
8		* Redistribution and use in source and binary forms, with or without
9		* modification, are permitted provided that the following conditions
10		* are met:
11		* 1. Redistributions of source code must retain the above copyright
12		* notice, this list of conditions and the following disclaimer.
13		* 2. Redistributions in binary form must reproduce the above copyright
14		* notice, this list of conditions and the following disclaimer in the
15		* documentation and/or other materials provided with the distribution.
16		*
17		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27		* SUCH DAMAGE.
28		*
29		* Generic memory pool
30		*/
31
32		#include "config.h"
33
34		#include "cache_varnishd.h"
35
36		#include <stdio.h>
37		#include <stdlib.h>
38
39		#include "vtim.h"
40
41		#include "VSC_mempool.h"
42
43		struct memitem {
44		unsigned magic;
45		#define MEMITEM_MAGIC 0x42e55401
46		unsigned size;
47		VTAILQ_ENTRY(memitem) list;
48		vtim_real touched; // XXX -> mono?
49		};
50
51		VTAILQ_HEAD(memhead_s, memitem);
52
53		struct mempool {
54		unsigned magic;
55		#define MEMPOOL_MAGIC 0x37a75a8d
56		char name[12];
57		struct memhead_s list;
58		struct memhead_s surplus;
59		struct lock mtx;
60		volatile struct poolparam *param;
61		volatile unsigned *cur_size;
62		uint64_t live;
63		struct vsc_seg *vsc_seg;
64		struct VSC_mempool *vsc;
65		unsigned n_pool;
66		pthread_t thread;
67		vtim_real t_now; // XXX -> mono?
68		int self_destruct;
69		};
70
71		/*---------------------------------------------------------------------
72		*/
73
74		static struct memitem *
75	1833829	mpl_alloc(const struct mempool *mpl)
76		{
77		unsigned tsz;
78		struct memitem *mi;
79
80	1833829	CHECK_OBJ_NOTNULL(mpl, MEMPOOL_MAGIC);
81	1833829	tsz = *mpl->cur_size;
82	1833829	mi = calloc(1, tsz);
83	1833829	AN(mi);
84	1833829	mi->magic = MEMITEM_MAGIC;
85	1833829	mi->size = tsz;
86	1833829	mpl->vsc->sz_wanted = tsz;
87	1833829	mpl->vsc->sz_actual = tsz - sizeof *mi;
88	1833829	return (mi);
89		}
90
91		/*---------------------------------------------------------------------
92		* Pool-guard
93		* Attempt to keep number of free items in pool inside bounds with
94		* minimum locking activity, and keep an eye on items at the tail
95		* of the list not getting too old.
96		*/
97
98		static void *
99	150	mpl_guard(void *priv)
100		{
101		struct mempool *mpl;
102	150	struct memitem *mi = NULL;
103		vtim_dur v_statevariable_(mpl_slp);
104	150	vtim_real last = 0;
105
106	150	CAST_OBJ_NOTNULL(mpl, priv, MEMPOOL_MAGIC);
107	150	THR_SetName(mpl->name);
108	150	THR_Init();
109	150	mpl_slp = 0.15; // random
110	1932438	while (1) {
111	2256877	VTIM_sleep(mpl_slp);
112	2256877	mpl_slp = 0.814; // random
113	2256877	mpl->t_now = VTIM_real();
114
115	2256877	if (mi != NULL && (mpl->n_pool > mpl->param->max_pool \|\|
116	6	mi->size < *mpl->cur_size)) {
117	0	CHECK_OBJ(mi, MEMITEM_MAGIC);
118	0	FREE_OBJ(mi);
119	0	}
120
121	2256877	if (mi == NULL && mpl->n_pool < mpl->param->min_pool)
122	1807990	mi = mpl_alloc(mpl);
123
124	2256877	if (mpl->n_pool < mpl->param->min_pool && mi != NULL) {
125		/* can do */
126	2256883	} else if (mpl->n_pool > mpl->param->max_pool && mi == NULL) {
127		/* can do */
128	422503	} else if (!VTAILQ_EMPTY(&mpl->surplus)) {
129		/* can do */
130	421594	} else if (last + .1 * mpl->param->max_age < mpl->t_now) {
131		/* should do */
132	421554	} else if (mpl->self_destruct) {
133		/* can do */
134	6	} else {
135	322510	continue; /* nothing to do */
136		}
137
138	1934373	mpl_slp = 0.314; // random
139
140	1934373	if (Lck_Trylock(&mpl->mtx))
141	1929	continue;
142
143	1932444	if (mpl->self_destruct) {
144	160	AZ(mpl->live);
145	1764	while (1) {
146	1764	if (mi == NULL) {
147	1760	mi = VTAILQ_FIRST(&mpl->list);
148	1760	if (mi != NULL) {
149	1603	mpl->vsc->pool = --mpl->n_pool;
150	1603	VTAILQ_REMOVE(&mpl->list,
151		mi, list);
152	1603	}
153	1760	}
154	1764	if (mi == NULL) {
155	160	mi = VTAILQ_FIRST(&mpl->surplus);
156	160	if (mi != NULL)
157	0	VTAILQ_REMOVE(&mpl->surplus,
158		mi, list);
159	160	}
160	1764	if (mi == NULL)
161	160	break;
162	1604	CHECK_OBJ(mi, MEMITEM_MAGIC);
163	1604	FREE_OBJ(mi);
164		}
165	160	VSC_mempool_Destroy(&mpl->vsc_seg);
166	160	Lck_Unlock(&mpl->mtx);
167	160	Lck_Delete(&mpl->mtx);
168	160	FREE_OBJ(mpl);
169	160	break;
170		}
171
172	3765550	if (mpl->n_pool < mpl->param->min_pool &&
173	1833875	mi != NULL && mi->size >= *mpl->cur_size) {
174	1832920	CHECK_OBJ(mi, MEMITEM_MAGIC);
175	1832920	mpl->vsc->pool = ++mpl->n_pool;
176	1832920	mi->touched = mpl->t_now;
177	1832920	VTAILQ_INSERT_HEAD(&mpl->list, mi, list);
178	1832920	mi = NULL;
179	1832920	mpl_slp = .01; // random
180
181	1832920	}
182	1932284	if (mpl->n_pool > mpl->param->max_pool && mi == NULL) {
183	909	mi = VTAILQ_FIRST(&mpl->list);
184	909	CHECK_OBJ_NOTNULL(mi, MEMITEM_MAGIC);
185	909	mpl->vsc->pool = --mpl->n_pool;
186	909	mpl->vsc->surplus++;
187	909	VTAILQ_REMOVE(&mpl->list, mi, list);
188	909	mpl_slp = .01; // random
189	909	}
190	1932288	if (mi == NULL) {
191	1931443	mi = VTAILQ_FIRST(&mpl->surplus);
192	1931443	if (mi != NULL) {
193	40	CHECK_OBJ(mi, MEMITEM_MAGIC);
194	40	VTAILQ_REMOVE(&mpl->surplus, mi, list);
195	40	mpl_slp = .01; // random
196	40	}
197	1931443	}
198	1932288	if (mi == NULL && mpl->n_pool > mpl->param->min_pool) {
199	15033	mi = VTAILQ_LAST(&mpl->list, memhead_s);
200	15033	CHECK_OBJ_NOTNULL(mi, MEMITEM_MAGIC);
201	15033	if (mi->touched + mpl->param->max_age < mpl->t_now) {
202	6138	mpl->vsc->pool = --mpl->n_pool;
203	6138	mpl->vsc->timeout++;
204	6138	VTAILQ_REMOVE(&mpl->list, mi, list);
205	6138	mpl_slp = .01; // random
206	6138	} else {
207	8895	mi = NULL;
208	8895	last = mpl->t_now;
209		}
210	1932288	} else if (mpl->n_pool <= mpl->param->min_pool) {
211	1916469	last = mpl->t_now;
212	1916469	}
213
214	1932288	Lck_Unlock(&mpl->mtx);
215
216	1932288	if (mi != NULL) {
217	7082	CHECK_OBJ(mi, MEMITEM_MAGIC);
218	7082	FREE_OBJ(mi);
219	7082	}
220		}
221	160	return (NULL);
222		}
223
224		/*---------------------------------------------------------------------
225		* Create a new memory pool, and start the guard thread for it.
226		*/
227
228		struct mempool *
229	181547	MPL_New(const char *name,
230		volatile struct poolparam pp, volatile unsigned cur_size)
231		{
232		struct mempool *mpl;
233
234	181547	ALLOC_OBJ(mpl, MEMPOOL_MAGIC);
235	181543	AN(mpl);
236	181543	bprintf(mpl->name, "MPL_%s", name);
237	181543	mpl->param = pp;
238	181543	mpl->cur_size = cur_size;
239	181543	VTAILQ_INIT(&mpl->list);
240	181543	VTAILQ_INIT(&mpl->surplus);
241	181543	Lck_New(&mpl->mtx, lck_mempool);
242		/* XXX: prealloc min_pool */
243	181543	mpl->vsc = VSC_mempool_New(NULL, &mpl->vsc_seg, mpl->name + 4);
244	181543	AN(mpl->vsc);
245	181543	PTOK(pthread_create(&mpl->thread, NULL, mpl_guard, mpl));
246	181543	PTOK(pthread_detach(mpl->thread));
247	181543	return (mpl);
248		}
249
250		/*---------------------------------------------------------------------
251		* Destroy a memory pool. There must be no live items, and we cheat
252		* and leave all the hard work to the guard thread.
253		*/
254
255		void
256	160	MPL_Destroy(struct mempool **mpp)
257		{
258		struct mempool *mpl;
259
260	160	TAKE_OBJ_NOTNULL(mpl, mpp, MEMPOOL_MAGIC);
261	160	Lck_Lock(&mpl->mtx);
262	160	AZ(mpl->live);
263	160	mpl->self_destruct = 1;
264	160	Lck_Unlock(&mpl->mtx);
265	160	}
266
267		/*---------------------------------------------------------------------
268		*/
269
270		void *
271	290726	MPL_Get(struct mempool mpl, unsigned size)
272		{
273		struct memitem *mi;
274
275	290726	CHECK_OBJ_NOTNULL(mpl, MEMPOOL_MAGIC);
276	290726	AN(size);
277
278	290726	Lck_Lock(&mpl->mtx);
279
280	290726	mpl->vsc->allocs++;
281	290726	mpl->vsc->live = ++mpl->live;
282
283	290726	do {
284	290762	mi = VTAILQ_FIRST(&mpl->list);
285	290762	if (mi == NULL) {
286	809	mpl->vsc->randry++;
287	809	break;
288		}
289	289953	mpl->vsc->pool = --mpl->n_pool;
290	289953	CHECK_OBJ(mi, MEMITEM_MAGIC);
291	289953	VTAILQ_REMOVE(&mpl->list, mi, list);
292	289953	if (mi->size < *mpl->cur_size) {
293	40	mpl->vsc->toosmall++;
294	40	VTAILQ_INSERT_HEAD(&mpl->surplus, mi, list);
295	40	mi = NULL;
296	40	} else {
297	289913	mpl->vsc->recycle++;
298		}
299	289953	} while (mi == NULL);
300
301	290740	Lck_Unlock(&mpl->mtx);
302
303	290740	if (mi == NULL)
304	809	mi = mpl_alloc(mpl);
305	290740	size = mi->size - sizeof mi;
306
307	290740	CHECK_OBJ(mi, MEMITEM_MAGIC);
308		/* Throw away sizeof info for FlexeLint: */
309	290740	return ((void *)(uintptr_t)(mi + 1));
310		}
311
312		void
313	288988	MPL_Free(struct mempool mpl, void item)
314		{
315		struct memitem *mi;
316
317	288988	CHECK_OBJ_NOTNULL(mpl, MEMPOOL_MAGIC);
318	288988	AN(item);
319
320	288988	mi = (void)((uintptr_t)item - sizeof(mi));
321	288988	CHECK_OBJ_NOTNULL(mi, MEMITEM_MAGIC);
322	288988	memset(item, 0, mi->size - sizeof *mi);
323
324	288988	Lck_Lock(&mpl->mtx);
325
326	288988	mpl->vsc->frees++;
327	288988	mpl->vsc->live = --mpl->live;
328
329	288988	if (mi->size < *mpl->cur_size) {
330	0	mpl->vsc->toosmall++;
331	0	VTAILQ_INSERT_HEAD(&mpl->surplus, mi, list);
332	0	} else {
333	288988	mpl->vsc->pool = ++mpl->n_pool;
334	288988	mi->touched = mpl->t_now;
335	288988	VTAILQ_INSERT_HEAD(&mpl->list, mi, list);
336		}
337
338	288988	Lck_Unlock(&mpl->mtx);
339	288988	}
340
341		void
342	116208	MPL_AssertSane(const void *item)
343		{
344		struct memitem *mi;
345	116208	mi = (void)((uintptr_t)item - sizeof(mi));
346	116208	CHECK_OBJ_NOTNULL(mi, MEMITEM_MAGIC);
347	116208	}