1 | /**
|
---|
2 | * @file
|
---|
3 | * Dynamic pool memory manager
|
---|
4 | *
|
---|
5 | * lwIP has dedicated pools for many structures (netconn, protocol control blocks,
|
---|
6 | * packet buffers, ...). All these pools are managed here.
|
---|
7 | */
|
---|
8 |
|
---|
9 | /*
|
---|
10 | * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
|
---|
11 | * All rights reserved.
|
---|
12 | *
|
---|
13 | * Redistribution and use in source and binary forms, with or without modification,
|
---|
14 | * are permitted provided that the following conditions are met:
|
---|
15 | *
|
---|
16 | * 1. Redistributions of source code must retain the above copyright notice,
|
---|
17 | * this list of conditions and the following disclaimer.
|
---|
18 | * 2. Redistributions in binary form must reproduce the above copyright notice,
|
---|
19 | * this list of conditions and the following disclaimer in the documentation
|
---|
20 | * and/or other materials provided with the distribution.
|
---|
21 | * 3. The name of the author may not be used to endorse or promote products
|
---|
22 | * derived from this software without specific prior written permission.
|
---|
23 | *
|
---|
24 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
---|
25 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
---|
26 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
|
---|
27 | * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
---|
28 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
|
---|
29 | * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
---|
30 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
---|
31 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
|
---|
32 | * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
|
---|
33 | * OF SUCH DAMAGE.
|
---|
34 | *
|
---|
35 | * This file is part of the lwIP TCP/IP stack.
|
---|
36 | *
|
---|
37 | * Author: Adam Dunkels <adam@sics.se>
|
---|
38 | *
|
---|
39 | */
|
---|
40 |
|
---|
41 | #include "lwip/opt.h"
|
---|
42 |
|
---|
43 | #include "lwip/memp.h"
|
---|
44 | #include "lwip/pbuf.h"
|
---|
45 | #include "lwip/udp.h"
|
---|
46 | #include "lwip/raw.h"
|
---|
47 | #include "lwip/tcp_impl.h"
|
---|
48 | #include "lwip/igmp.h"
|
---|
49 | #include "lwip/api.h"
|
---|
50 | #include "lwip/api_msg.h"
|
---|
51 | #include "lwip/tcpip.h"
|
---|
52 | #include "lwip/sys.h"
|
---|
53 | #include "lwip/timers.h"
|
---|
54 | #include "lwip/stats.h"
|
---|
55 | #include "netif/etharp.h"
|
---|
56 | #include "lwip/ip_frag.h"
|
---|
57 | #include "lwip/snmp_structs.h"
|
---|
58 | #include "lwip/snmp_msg.h"
|
---|
59 | #include "lwip/dns.h"
|
---|
60 | #include "netif/ppp_oe.h"
|
---|
61 |
|
---|
62 | #include <string.h>
|
---|
63 |
|
---|
64 | #if !MEMP_MEM_MALLOC /* don't build if not configured for use in lwipopts.h */
|
---|
65 |
|
---|
66 | struct memp {
|
---|
67 | struct memp *next;
|
---|
68 | #if MEMP_OVERFLOW_CHECK
|
---|
69 | const char *file;
|
---|
70 | int line;
|
---|
71 | #endif /* MEMP_OVERFLOW_CHECK */
|
---|
72 | };
|
---|
73 |
|
---|
74 | #if MEMP_OVERFLOW_CHECK
|
---|
75 | /* if MEMP_OVERFLOW_CHECK is turned on, we reserve some bytes at the beginning
|
---|
76 | * and at the end of each element, initialize them as 0xcd and check
|
---|
77 | * them later. */
|
---|
78 | /* If MEMP_OVERFLOW_CHECK is >= 2, on every call to memp_malloc or memp_free,
|
---|
79 | * every single element in each pool is checked!
|
---|
80 | * This is VERY SLOW but also very helpful. */
|
---|
81 | /* MEMP_SANITY_REGION_BEFORE and MEMP_SANITY_REGION_AFTER can be overridden in
|
---|
82 | * lwipopts.h to change the amount reserved for checking. */
|
---|
83 | #ifndef MEMP_SANITY_REGION_BEFORE
|
---|
84 | #define MEMP_SANITY_REGION_BEFORE 16
|
---|
85 | #endif /* MEMP_SANITY_REGION_BEFORE*/
|
---|
86 | #if MEMP_SANITY_REGION_BEFORE > 0
|
---|
87 | #define MEMP_SANITY_REGION_BEFORE_ALIGNED LWIP_MEM_ALIGN_SIZE(MEMP_SANITY_REGION_BEFORE)
|
---|
88 | #else
|
---|
89 | #define MEMP_SANITY_REGION_BEFORE_ALIGNED 0
|
---|
90 | #endif /* MEMP_SANITY_REGION_BEFORE*/
|
---|
91 | #ifndef MEMP_SANITY_REGION_AFTER
|
---|
92 | #define MEMP_SANITY_REGION_AFTER 16
|
---|
93 | #endif /* MEMP_SANITY_REGION_AFTER*/
|
---|
94 | #if MEMP_SANITY_REGION_AFTER > 0
|
---|
95 | #define MEMP_SANITY_REGION_AFTER_ALIGNED LWIP_MEM_ALIGN_SIZE(MEMP_SANITY_REGION_AFTER)
|
---|
96 | #else
|
---|
97 | #define MEMP_SANITY_REGION_AFTER_ALIGNED 0
|
---|
98 | #endif /* MEMP_SANITY_REGION_AFTER*/
|
---|
99 |
|
---|
100 | /* MEMP_SIZE: save space for struct memp and for sanity check */
|
---|
101 | #define MEMP_SIZE (LWIP_MEM_ALIGN_SIZE(sizeof(struct memp)) + MEMP_SANITY_REGION_BEFORE_ALIGNED)
|
---|
102 | #define MEMP_ALIGN_SIZE(x) (LWIP_MEM_ALIGN_SIZE(x) + MEMP_SANITY_REGION_AFTER_ALIGNED)
|
---|
103 |
|
---|
104 | #else /* MEMP_OVERFLOW_CHECK */
|
---|
105 |
|
---|
106 | /* No sanity checks
|
---|
107 | * We don't need to preserve the struct memp while not allocated, so we
|
---|
108 | * can save a little space and set MEMP_SIZE to 0.
|
---|
109 | */
|
---|
110 | #define MEMP_SIZE 0
|
---|
111 | #define MEMP_ALIGN_SIZE(x) (LWIP_MEM_ALIGN_SIZE(x))
|
---|
112 |
|
---|
113 | #endif /* MEMP_OVERFLOW_CHECK */
|
---|
114 |
|
---|
115 | /** This array holds the first free element of each pool.
|
---|
116 | * Elements form a linked list. */
|
---|
117 | static struct memp *memp_tab[MEMP_MAX];
|
---|
118 |
|
---|
119 | #else /* MEMP_MEM_MALLOC */
|
---|
120 |
|
---|
121 | #define MEMP_ALIGN_SIZE(x) (LWIP_MEM_ALIGN_SIZE(x))
|
---|
122 |
|
---|
123 | #endif /* MEMP_MEM_MALLOC */
|
---|
124 |
|
---|
125 | /** This array holds the element sizes of each pool. */
|
---|
126 | #if !MEM_USE_POOLS && !MEMP_MEM_MALLOC
|
---|
127 | static
|
---|
128 | #endif
|
---|
129 | const u16_t memp_sizes[MEMP_MAX] = {
|
---|
130 | #define LWIP_MEMPOOL(name,num,size,desc) LWIP_MEM_ALIGN_SIZE(size),
|
---|
131 | #include "lwip/memp_std.h"
|
---|
132 | };
|
---|
133 |
|
---|
134 | #if !MEMP_MEM_MALLOC /* don't build if not configured for use in lwipopts.h */
|
---|
135 |
|
---|
136 | /** This array holds the number of elements in each pool. */
|
---|
137 | static const u16_t memp_num[MEMP_MAX] = {
|
---|
138 | #define LWIP_MEMPOOL(name,num,size,desc) (num),
|
---|
139 | #include "lwip/memp_std.h"
|
---|
140 | };
|
---|
141 |
|
---|
142 | /** This array holds a textual description of each pool. */
|
---|
143 | #ifdef LWIP_DEBUG
|
---|
144 | static const char *memp_desc[MEMP_MAX] = {
|
---|
145 | #define LWIP_MEMPOOL(name,num,size,desc) (desc),
|
---|
146 | #include "lwip/memp_std.h"
|
---|
147 | };
|
---|
148 | #endif /* LWIP_DEBUG */
|
---|
149 |
|
---|
150 | #if MEMP_SEPARATE_POOLS
|
---|
151 |
|
---|
152 | /** This creates each memory pool. These are named memp_memory_XXX_base (where
|
---|
153 | * XXX is the name of the pool defined in memp_std.h).
|
---|
154 | * To relocate a pool, declare it as extern in cc.h. Example for GCC:
|
---|
155 | * extern u8_t __attribute__((section(".onchip_mem"))) memp_memory_UDP_PCB_base[];
|
---|
156 | */
|
---|
157 | #define LWIP_MEMPOOL(name,num,size,desc) u8_t memp_memory_ ## name ## _base \
|
---|
158 | [((num) * (MEMP_SIZE + MEMP_ALIGN_SIZE(size)))];
|
---|
159 | #include "lwip/memp_std.h"
|
---|
160 |
|
---|
161 | /** This array holds the base of each memory pool. */
|
---|
162 | static u8_t *const memp_bases[] = {
|
---|
163 | #define LWIP_MEMPOOL(name,num,size,desc) memp_memory_ ## name ## _base,
|
---|
164 | #include "lwip/memp_std.h"
|
---|
165 | };
|
---|
166 |
|
---|
167 | #else /* MEMP_SEPARATE_POOLS */
|
---|
168 |
|
---|
169 | /** This is the actual memory used by the pools (all pools in one big block). */
|
---|
170 | static u8_t memp_memory[MEM_ALIGNMENT - 1
|
---|
171 | #define LWIP_MEMPOOL(name,num,size,desc) + ( (num) * (MEMP_SIZE + MEMP_ALIGN_SIZE(size) ) )
|
---|
172 | #include "lwip/memp_std.h"
|
---|
173 | ];
|
---|
174 |
|
---|
175 | #endif /* MEMP_SEPARATE_POOLS */
|
---|
176 |
|
---|
177 | #if MEMP_SANITY_CHECK
|
---|
178 | /**
|
---|
179 | * Check that memp-lists don't form a circle, using "Floyd's cycle-finding algorithm".
|
---|
180 | */
|
---|
181 | static int
|
---|
182 | memp_sanity(void)
|
---|
183 | {
|
---|
184 | s16_t i;
|
---|
185 | struct memp *t, *h;
|
---|
186 |
|
---|
187 | for (i = 0; i < MEMP_MAX; i++) {
|
---|
188 | t = memp_tab[i];
|
---|
189 | if(t != NULL) {
|
---|
190 | for (h = t->next; (t != NULL) && (h != NULL); t = t->next,
|
---|
191 | h = (((h->next != NULL) && (h->next->next != NULL)) ? h->next->next : NULL)) {
|
---|
192 | if (t == h) {
|
---|
193 | return 0;
|
---|
194 | }
|
---|
195 | }
|
---|
196 | }
|
---|
197 | }
|
---|
198 | return 1;
|
---|
199 | }
|
---|
200 | #endif /* MEMP_SANITY_CHECK*/
|
---|
201 | #if MEMP_OVERFLOW_CHECK
|
---|
202 | #if defined(LWIP_DEBUG) && MEMP_STATS
|
---|
203 | static const char * memp_overflow_names[] = {
|
---|
204 | #define LWIP_MEMPOOL(name,num,size,desc) "/"desc,
|
---|
205 | #include "lwip/memp_std.h"
|
---|
206 | };
|
---|
207 | #endif
|
---|
208 |
|
---|
209 | /**
|
---|
210 | * Check if a memp element was victim of an overflow
|
---|
211 | * (e.g. the restricted area after it has been altered)
|
---|
212 | *
|
---|
213 | * @param p the memp element to check
|
---|
214 | * @param memp_type the pool p comes from
|
---|
215 | */
|
---|
216 | static void
|
---|
217 | memp_overflow_check_element_overflow(struct memp *p, u16_t memp_type)
|
---|
218 | {
|
---|
219 | u16_t k;
|
---|
220 | u8_t *m;
|
---|
221 | #if MEMP_SANITY_REGION_AFTER_ALIGNED > 0
|
---|
222 | m = (u8_t*)p + MEMP_SIZE + memp_sizes[memp_type];
|
---|
223 | for (k = 0; k < MEMP_SANITY_REGION_AFTER_ALIGNED; k++) {
|
---|
224 | if (m[k] != 0xcd) {
|
---|
225 | char errstr[128] = "detected memp overflow in pool ";
|
---|
226 | char digit[] = "0";
|
---|
227 | if(memp_type >= 10) {
|
---|
228 | digit[0] = '0' + (memp_type/10);
|
---|
229 | strcat(errstr, digit);
|
---|
230 | }
|
---|
231 | digit[0] = '0' + (memp_type%10);
|
---|
232 | strcat(errstr, digit);
|
---|
233 | #if defined(LWIP_DEBUG) && MEMP_STATS
|
---|
234 | strcat(errstr, memp_overflow_names[memp_type]);
|
---|
235 | #endif
|
---|
236 | LWIP_ASSERT(errstr, 0);
|
---|
237 | }
|
---|
238 | }
|
---|
239 | #endif
|
---|
240 | }
|
---|
241 |
|
---|
242 | /**
|
---|
243 | * Check if a memp element was victim of an underflow
|
---|
244 | * (e.g. the restricted area before it has been altered)
|
---|
245 | *
|
---|
246 | * @param p the memp element to check
|
---|
247 | * @param memp_type the pool p comes from
|
---|
248 | */
|
---|
249 | static void
|
---|
250 | memp_overflow_check_element_underflow(struct memp *p, u16_t memp_type)
|
---|
251 | {
|
---|
252 | u16_t k;
|
---|
253 | u8_t *m;
|
---|
254 | #if MEMP_SANITY_REGION_BEFORE_ALIGNED > 0
|
---|
255 | m = (u8_t*)p + MEMP_SIZE - MEMP_SANITY_REGION_BEFORE_ALIGNED;
|
---|
256 | for (k = 0; k < MEMP_SANITY_REGION_BEFORE_ALIGNED; k++) {
|
---|
257 | if (m[k] != 0xcd) {
|
---|
258 | char errstr[128] = "detected memp underflow in pool ";
|
---|
259 | char digit[] = "0";
|
---|
260 | if(memp_type >= 10) {
|
---|
261 | digit[0] = '0' + (memp_type/10);
|
---|
262 | strcat(errstr, digit);
|
---|
263 | }
|
---|
264 | digit[0] = '0' + (memp_type%10);
|
---|
265 | strcat(errstr, digit);
|
---|
266 | #if defined(LWIP_DEBUG) && MEMP_STATS
|
---|
267 | strcat(errstr, memp_overflow_names[memp_type]);
|
---|
268 | #endif
|
---|
269 | LWIP_ASSERT(errstr, 0);
|
---|
270 | }
|
---|
271 | }
|
---|
272 | #endif
|
---|
273 | }
|
---|
274 |
|
---|
275 | /**
|
---|
276 | * Do an overflow check for all elements in every pool.
|
---|
277 | *
|
---|
278 | * @see memp_overflow_check_element for a description of the check
|
---|
279 | */
|
---|
280 | static void
|
---|
281 | memp_overflow_check_all(void)
|
---|
282 | {
|
---|
283 | u16_t i, j;
|
---|
284 | struct memp *p;
|
---|
285 |
|
---|
286 | p = (struct memp *)LWIP_MEM_ALIGN(memp_memory);
|
---|
287 | for (i = 0; i < MEMP_MAX; ++i) {
|
---|
288 | p = p;
|
---|
289 | for (j = 0; j < memp_num[i]; ++j) {
|
---|
290 | memp_overflow_check_element_overflow(p, i);
|
---|
291 | p = (struct memp*)((u8_t*)p + MEMP_SIZE + memp_sizes[i] + MEMP_SANITY_REGION_AFTER_ALIGNED);
|
---|
292 | }
|
---|
293 | }
|
---|
294 | p = (struct memp *)LWIP_MEM_ALIGN(memp_memory);
|
---|
295 | for (i = 0; i < MEMP_MAX; ++i) {
|
---|
296 | p = p;
|
---|
297 | for (j = 0; j < memp_num[i]; ++j) {
|
---|
298 | memp_overflow_check_element_underflow(p, i);
|
---|
299 | p = (struct memp*)((u8_t*)p + MEMP_SIZE + memp_sizes[i] + MEMP_SANITY_REGION_AFTER_ALIGNED);
|
---|
300 | }
|
---|
301 | }
|
---|
302 | }
|
---|
303 |
|
---|
304 | /**
|
---|
305 | * Initialize the restricted areas of all memp elements in every pool.
|
---|
306 | */
|
---|
307 | static void
|
---|
308 | memp_overflow_init(void)
|
---|
309 | {
|
---|
310 | u16_t i, j;
|
---|
311 | struct memp *p;
|
---|
312 | u8_t *m;
|
---|
313 |
|
---|
314 | p = (struct memp *)LWIP_MEM_ALIGN(memp_memory);
|
---|
315 | for (i = 0; i < MEMP_MAX; ++i) {
|
---|
316 | p = p;
|
---|
317 | for (j = 0; j < memp_num[i]; ++j) {
|
---|
318 | #if MEMP_SANITY_REGION_BEFORE_ALIGNED > 0
|
---|
319 | m = (u8_t*)p + MEMP_SIZE - MEMP_SANITY_REGION_BEFORE_ALIGNED;
|
---|
320 | memset(m, 0xcd, MEMP_SANITY_REGION_BEFORE_ALIGNED);
|
---|
321 | #endif
|
---|
322 | #if MEMP_SANITY_REGION_AFTER_ALIGNED > 0
|
---|
323 | m = (u8_t*)p + MEMP_SIZE + memp_sizes[i];
|
---|
324 | memset(m, 0xcd, MEMP_SANITY_REGION_AFTER_ALIGNED);
|
---|
325 | #endif
|
---|
326 | p = (struct memp*)((u8_t*)p + MEMP_SIZE + memp_sizes[i] + MEMP_SANITY_REGION_AFTER_ALIGNED);
|
---|
327 | }
|
---|
328 | }
|
---|
329 | }
|
---|
330 | #endif /* MEMP_OVERFLOW_CHECK */
|
---|
331 |
|
---|
332 | /**
|
---|
333 | * Initialize this module.
|
---|
334 | *
|
---|
335 | * Carves out memp_memory into linked lists for each pool-type.
|
---|
336 | */
|
---|
337 | void
|
---|
338 | memp_init(void)
|
---|
339 | {
|
---|
340 | struct memp *memp;
|
---|
341 | u16_t i, j;
|
---|
342 |
|
---|
343 | for (i = 0; i < MEMP_MAX; ++i) {
|
---|
344 | MEMP_STATS_AVAIL(used, i, 0);
|
---|
345 | MEMP_STATS_AVAIL(max, i, 0);
|
---|
346 | MEMP_STATS_AVAIL(err, i, 0);
|
---|
347 | MEMP_STATS_AVAIL(avail, i, memp_num[i]);
|
---|
348 | }
|
---|
349 |
|
---|
350 | #if !MEMP_SEPARATE_POOLS
|
---|
351 | memp = (struct memp *)LWIP_MEM_ALIGN(memp_memory);
|
---|
352 | #endif /* !MEMP_SEPARATE_POOLS */
|
---|
353 | /* for every pool: */
|
---|
354 | for (i = 0; i < MEMP_MAX; ++i) {
|
---|
355 | memp_tab[i] = NULL;
|
---|
356 | #if MEMP_SEPARATE_POOLS
|
---|
357 | memp = (struct memp*)memp_bases[i];
|
---|
358 | #endif /* MEMP_SEPARATE_POOLS */
|
---|
359 | /* create a linked list of memp elements */
|
---|
360 | for (j = 0; j < memp_num[i]; ++j) {
|
---|
361 | memp->next = memp_tab[i];
|
---|
362 | memp_tab[i] = memp;
|
---|
363 | memp = (struct memp *)(void *)((u8_t *)memp + MEMP_SIZE + memp_sizes[i]
|
---|
364 | #if MEMP_OVERFLOW_CHECK
|
---|
365 | + MEMP_SANITY_REGION_AFTER_ALIGNED
|
---|
366 | #endif
|
---|
367 | );
|
---|
368 | }
|
---|
369 | }
|
---|
370 | #if MEMP_OVERFLOW_CHECK
|
---|
371 | memp_overflow_init();
|
---|
372 | /* check everything a first time to see if it worked */
|
---|
373 | memp_overflow_check_all();
|
---|
374 | #endif /* MEMP_OVERFLOW_CHECK */
|
---|
375 | }
|
---|
376 |
|
---|
377 | /**
|
---|
378 | * Get an element from a specific pool.
|
---|
379 | *
|
---|
380 | * @param type the pool to get an element from
|
---|
381 | *
|
---|
382 | * the debug version has two more parameters:
|
---|
383 | * @param file file name calling this function
|
---|
384 | * @param line number of line where this function is called
|
---|
385 | *
|
---|
386 | * @return a pointer to the allocated memory or a NULL pointer on error
|
---|
387 | */
|
---|
388 | void *
|
---|
389 | #if !MEMP_OVERFLOW_CHECK
|
---|
390 | memp_malloc(memp_t type)
|
---|
391 | #else
|
---|
392 | memp_malloc_fn(memp_t type, const char* file, const int line)
|
---|
393 | #endif
|
---|
394 | {
|
---|
395 | struct memp *memp;
|
---|
396 | SYS_ARCH_DECL_PROTECT(old_level);
|
---|
397 |
|
---|
398 | LWIP_ERROR("memp_malloc: type < MEMP_MAX", (type < MEMP_MAX), return NULL;);
|
---|
399 |
|
---|
400 | SYS_ARCH_PROTECT(old_level);
|
---|
401 | #if MEMP_OVERFLOW_CHECK >= 2
|
---|
402 | memp_overflow_check_all();
|
---|
403 | #endif /* MEMP_OVERFLOW_CHECK >= 2 */
|
---|
404 |
|
---|
405 | memp = memp_tab[type];
|
---|
406 |
|
---|
407 | if (memp != NULL) {
|
---|
408 | memp_tab[type] = memp->next;
|
---|
409 | #if MEMP_OVERFLOW_CHECK
|
---|
410 | memp->next = NULL;
|
---|
411 | memp->file = file;
|
---|
412 | memp->line = line;
|
---|
413 | #endif /* MEMP_OVERFLOW_CHECK */
|
---|
414 | MEMP_STATS_INC_USED(used, type);
|
---|
415 | LWIP_ASSERT("memp_malloc: memp properly aligned",
|
---|
416 | ((mem_ptr_t)memp % MEM_ALIGNMENT) == 0);
|
---|
417 | memp = (struct memp*)(void *)((u8_t*)memp + MEMP_SIZE);
|
---|
418 | } else {
|
---|
419 | LWIP_DEBUGF(MEMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("memp_malloc: out of memory in pool %s\n", memp_desc[type]));
|
---|
420 | MEMP_STATS_INC(err, type);
|
---|
421 | }
|
---|
422 |
|
---|
423 | SYS_ARCH_UNPROTECT(old_level);
|
---|
424 |
|
---|
425 | return memp;
|
---|
426 | }
|
---|
427 |
|
---|
428 | /**
|
---|
429 | * Put an element back into its pool.
|
---|
430 | *
|
---|
431 | * @param type the pool where to put mem
|
---|
432 | * @param mem the memp element to free
|
---|
433 | */
|
---|
434 | void
|
---|
435 | memp_free(memp_t type, void *mem)
|
---|
436 | {
|
---|
437 | struct memp *memp;
|
---|
438 | SYS_ARCH_DECL_PROTECT(old_level);
|
---|
439 |
|
---|
440 | if (mem == NULL) {
|
---|
441 | return;
|
---|
442 | }
|
---|
443 | LWIP_ASSERT("memp_free: mem properly aligned",
|
---|
444 | ((mem_ptr_t)mem % MEM_ALIGNMENT) == 0);
|
---|
445 |
|
---|
446 | memp = (struct memp *)(void *)((u8_t*)mem - MEMP_SIZE);
|
---|
447 |
|
---|
448 | SYS_ARCH_PROTECT(old_level);
|
---|
449 | #if MEMP_OVERFLOW_CHECK
|
---|
450 | #if MEMP_OVERFLOW_CHECK >= 2
|
---|
451 | memp_overflow_check_all();
|
---|
452 | #else
|
---|
453 | memp_overflow_check_element_overflow(memp, type);
|
---|
454 | memp_overflow_check_element_underflow(memp, type);
|
---|
455 | #endif /* MEMP_OVERFLOW_CHECK >= 2 */
|
---|
456 | #endif /* MEMP_OVERFLOW_CHECK */
|
---|
457 |
|
---|
458 | MEMP_STATS_DEC(used, type);
|
---|
459 |
|
---|
460 | memp->next = memp_tab[type];
|
---|
461 | memp_tab[type] = memp;
|
---|
462 |
|
---|
463 | #if MEMP_SANITY_CHECK
|
---|
464 | LWIP_ASSERT("memp sanity", memp_sanity());
|
---|
465 | #endif /* MEMP_SANITY_CHECK */
|
---|
466 |
|
---|
467 | SYS_ARCH_UNPROTECT(old_level);
|
---|
468 | }
|
---|
469 |
|
---|
470 | #endif /* MEMP_MEM_MALLOC */
|
---|