[164] | 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 */
|
---|