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 * @defgroup mempool Memory pools 9 * @ingroup infrastructure 10 * Custom memory pools 11 12 */ 13 14 /* 15 * Copyright (c) 2001-2004 Swedish Institute of Computer Science. 16 * All rights reserved. 17 * 18 * Redistribution and use in source and binary forms, with or without modification, 19 * are permitted provided that the following conditions are met: 20 * 21 * 1. Redistributions of source code must retain the above copyright notice, 22 * this list of conditions and the following disclaimer. 23 * 2. Redistributions in binary form must reproduce the above copyright notice, 24 * this list of conditions and the following disclaimer in the documentation 25 * and/or other materials provided with the distribution. 26 * 3. The name of the author may not be used to endorse or promote products 27 * derived from this software without specific prior written permission. 28 * 29 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 30 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 31 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 32 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 33 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 34 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 35 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 36 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 37 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 38 * OF SUCH DAMAGE. 39 * 40 * This file is part of the lwIP TCP/IP stack. 41 * 42 * Author: Adam Dunkels <adam@sics.se> 43 * 44 */ 45 46 #include "lwip/opt.h" 47 48 #include "lwip/memp.h" 49 #include "lwip/sys.h" 50 #include "lwip/stats.h" 51 52 #include <string.h> 53 54 /* Make sure we include everything we need for size calculation required by memp_std.h */ 55 #include "lwip/pbuf.h" 56 #include "lwip/raw.h" 57 #include "lwip/udp.h" 58 #include "lwip/tcp.h" 59 #include "lwip/priv/tcp_priv.h" 60 #include "lwip/ip4_frag.h" 61 #include "lwip/netbuf.h" 62 #include "lwip/api.h" 63 #include "lwip/priv/tcpip_priv.h" 64 #include "lwip/priv/api_msg.h" 65 #include "lwip/sockets.h" 66 #include "lwip/priv/sockets_priv.h" 67 #include "lwip/netifapi.h" 68 #include "lwip/etharp.h" 69 #include "lwip/igmp.h" 70 #include "lwip/timeouts.h" 71 /* needed by default MEMP_NUM_SYS_TIMEOUT */ 72 #include "netif/ppp/ppp_opts.h" 73 #include "lwip/netdb.h" 74 #include "lwip/dns.h" 75 #include "lwip/priv/nd6_priv.h" 76 #include "lwip/ip6_frag.h" 77 #include "lwip/mld6.h" 78 79 #define LWIP_MEMPOOL(name,num,size,desc) LWIP_MEMPOOL_DECLARE(name,num,size,desc) 80 #include "lwip/priv/memp_std.h" 81 82 const struct memp_desc* const memp_pools[MEMP_MAX] = { 83 #define LWIP_MEMPOOL(name,num,size,desc) &memp_ ## name, 84 #include "lwip/priv/memp_std.h" 85 }; 86 87 #ifdef LWIP_HOOK_FILENAME 88 #include LWIP_HOOK_FILENAME 89 #endif 90 91 #if MEMP_MEM_MALLOC && MEMP_OVERFLOW_CHECK >= 2 92 #undef MEMP_OVERFLOW_CHECK 93 /* MEMP_OVERFLOW_CHECK >= 2 does not work with MEMP_MEM_MALLOC, use 1 instead */ 94 #define MEMP_OVERFLOW_CHECK 1 95 #endif 96 97 #if MEMP_SANITY_CHECK && !MEMP_MEM_MALLOC 98 /** 99 * Check that memp-lists don't form a circle, using "Floyd's cycle-finding algorithm". 100 */ 101 static int 102 memp_sanity(const struct memp_desc *desc) 103 { 104 struct memp *t, *h; 105 106 t = *desc->tab; 107 if (t != NULL) { 108 for (h = t->next; (t != NULL) && (h != NULL); t = t->next, 109 h = ((h->next != NULL) ? h->next->next : NULL)) { 110 if (t == h) { 111 return 0; 112 } 113 } 114 } 115 116 return 1; 117 } 118 #endif /* MEMP_SANITY_CHECK && !MEMP_MEM_MALLOC */ 119 120 #if MEMP_OVERFLOW_CHECK 121 /** 122 * Check if a memp element was victim of an overflow 123 * (e.g. the restricted area after it has been altered) 124 * 125 * @param p the memp element to check 126 * @param desc the pool p comes from 127 */ 128 static void 129 memp_overflow_check_element_overflow(struct memp *p, const struct memp_desc *desc) 130 { 131 #if MEMP_SANITY_REGION_AFTER_ALIGNED > 0 132 u16_t k; 133 u8_t *m; 134 m = (u8_t*)p + MEMP_SIZE + desc->size; 135 for (k = 0; k < MEMP_SANITY_REGION_AFTER_ALIGNED; k++) { 136 if (m[k] != 0xcd) { 137 char errstr[128] = "detected memp overflow in pool "; 138 strcat(errstr, desc->desc); 139 LWIP_ASSERT(errstr, 0); 140 } 141 } 142 #else /* MEMP_SANITY_REGION_AFTER_ALIGNED > 0 */ 143 LWIP_UNUSED_ARG(p); 144 LWIP_UNUSED_ARG(desc); 145 #endif /* MEMP_SANITY_REGION_AFTER_ALIGNED > 0 */ 146 } 147 148 /** 149 * Check if a memp element was victim of an underflow 150 * (e.g. the restricted area before it has been altered) 151 * 152 * @param p the memp element to check 153 * @param desc the pool p comes from 154 */ 155 static void 156 memp_overflow_check_element_underflow(struct memp *p, const struct memp_desc *desc) 157 { 158 #if MEMP_SANITY_REGION_BEFORE_ALIGNED > 0 159 u16_t k; 160 u8_t *m; 161 m = (u8_t*)p + MEMP_SIZE - MEMP_SANITY_REGION_BEFORE_ALIGNED; 162 for (k = 0; k < MEMP_SANITY_REGION_BEFORE_ALIGNED; k++) { 163 if (m[k] != 0xcd) { 164 char errstr[128] = "detected memp underflow in pool "; 165 strcat(errstr, desc->desc); 166 LWIP_ASSERT(errstr, 0); 167 } 168 } 169 #else /* MEMP_SANITY_REGION_BEFORE_ALIGNED > 0 */ 170 LWIP_UNUSED_ARG(p); 171 LWIP_UNUSED_ARG(desc); 172 #endif /* MEMP_SANITY_REGION_BEFORE_ALIGNED > 0 */ 173 } 174 175 /** 176 * Initialize the restricted area of on memp element. 177 */ 178 static void 179 memp_overflow_init_element(struct memp *p, const struct memp_desc *desc) 180 { 181 #if MEMP_SANITY_REGION_BEFORE_ALIGNED > 0 || MEMP_SANITY_REGION_AFTER_ALIGNED > 0 182 u8_t *m; 183 #if MEMP_SANITY_REGION_BEFORE_ALIGNED > 0 184 m = (u8_t*)p + MEMP_SIZE - MEMP_SANITY_REGION_BEFORE_ALIGNED; 185 memset(m, 0xcd, MEMP_SANITY_REGION_BEFORE_ALIGNED); 186 #endif 187 #if MEMP_SANITY_REGION_AFTER_ALIGNED > 0 188 m = (u8_t*)p + MEMP_SIZE + desc->size; 189 memset(m, 0xcd, MEMP_SANITY_REGION_AFTER_ALIGNED); 190 #endif 191 #else /* MEMP_SANITY_REGION_BEFORE_ALIGNED > 0 || MEMP_SANITY_REGION_AFTER_ALIGNED > 0 */ 192 LWIP_UNUSED_ARG(p); 193 LWIP_UNUSED_ARG(desc); 194 #endif /* MEMP_SANITY_REGION_BEFORE_ALIGNED > 0 || MEMP_SANITY_REGION_AFTER_ALIGNED > 0 */ 195 } 196 197 #if MEMP_OVERFLOW_CHECK >= 2 198 /** 199 * Do an overflow check for all elements in every pool. 200 * 201 * @see memp_overflow_check_element for a description of the check 202 */ 203 static void 204 memp_overflow_check_all(void) 205 { 206 u16_t i, j; 207 struct memp *p; 208 SYS_ARCH_DECL_PROTECT(old_level); 209 SYS_ARCH_PROTECT(old_level); 210 211 for (i = 0; i < MEMP_MAX; ++i) { 212 p = (struct memp*)LWIP_MEM_ALIGN(memp_pools[i]->base); 213 for (j = 0; j < memp_pools[i]->num; ++j) { 214 memp_overflow_check_element_overflow(p, memp_pools[i]); 215 memp_overflow_check_element_underflow(p, memp_pools[i]); 216 p = LWIP_ALIGNMENT_CAST(struct memp*, ((u8_t*)p + MEMP_SIZE + memp_pools[i]->size + MEMP_SANITY_REGION_AFTER_ALIGNED)); 217 } 218 } 219 SYS_ARCH_UNPROTECT(old_level); 220 } 221 #endif /* MEMP_OVERFLOW_CHECK >= 2 */ 222 #endif /* MEMP_OVERFLOW_CHECK */ 223 224 /** 225 * Initialize custom memory pool. 226 * Related functions: memp_malloc_pool, memp_free_pool 227 * 228 * @param desc pool to initialize 229 */ 230 void 231 memp_init_pool(const struct memp_desc *desc) 232 { 233 #if MEMP_MEM_MALLOC 234 LWIP_UNUSED_ARG(desc); 235 #else 236 int i; 237 struct memp *memp; 238 239 *desc->tab = NULL; 240 memp = (struct memp*)LWIP_MEM_ALIGN(desc->base); 241 /* create a linked list of memp elements */ 242 for (i = 0; i < desc->num; ++i) { 243 memp->next = *desc->tab; 244 *desc->tab = memp; 245 #if MEMP_OVERFLOW_CHECK 246 memp_overflow_init_element(memp, desc); 247 #endif /* MEMP_OVERFLOW_CHECK */ 248 /* cast through void* to get rid of alignment warnings */ 249 memp = (struct memp *)(void *)((u8_t *)memp + MEMP_SIZE + desc->size 250 #if MEMP_OVERFLOW_CHECK 251 + MEMP_SANITY_REGION_AFTER_ALIGNED 252 #endif 253 ); 254 } 255 #if MEMP_STATS 256 desc->stats->avail = desc->num; 257 #endif /* MEMP_STATS */ 258 #endif /* !MEMP_MEM_MALLOC */ 259 260 #if MEMP_STATS && (defined(LWIP_DEBUG) || LWIP_STATS_DISPLAY) 261 desc->stats->name = desc->desc; 262 #endif /* MEMP_STATS && (defined(LWIP_DEBUG) || LWIP_STATS_DISPLAY) */ 263 } 264 265 /** 266 * Initializes lwIP built-in pools. 267 * Related functions: memp_malloc, memp_free 268 * 269 * Carves out memp_memory into linked lists for each pool-type. 270 */ 271 void 272 memp_init(void) 273 { 274 u16_t i; 275 276 /* for every pool: */ 277 for (i = 0; i < LWIP_ARRAYSIZE(memp_pools); i++) { 278 memp_init_pool(memp_pools[i]); 279 280 #if LWIP_STATS && MEMP_STATS 281 lwip_stats.memp[i] = memp_pools[i]->stats; 282 #endif 283 } 284 285 #if MEMP_OVERFLOW_CHECK >= 2 286 /* check everything a first time to see if it worked */ 287 memp_overflow_check_all(); 288 #endif /* MEMP_OVERFLOW_CHECK >= 2 */ 289 } 290 291 static void* 292 #if !MEMP_OVERFLOW_CHECK 293 do_memp_malloc_pool(const struct memp_desc *desc) 294 #else 295 do_memp_malloc_pool_fn(const struct memp_desc *desc, const char* file, const int line) 296 #endif 297 { 298 struct memp *memp; 299 SYS_ARCH_DECL_PROTECT(old_level); 300 301 #if MEMP_MEM_MALLOC 302 memp = (struct memp *)mem_malloc(MEMP_SIZE + MEMP_ALIGN_SIZE(desc->size)); 303 SYS_ARCH_PROTECT(old_level); 304 #else /* MEMP_MEM_MALLOC */ 305 SYS_ARCH_PROTECT(old_level); 306 307 memp = *desc->tab; 308 #endif /* MEMP_MEM_MALLOC */ 309 310 if (memp != NULL) { 311 #if !MEMP_MEM_MALLOC 312 #if MEMP_OVERFLOW_CHECK == 1 313 memp_overflow_check_element_overflow(memp, desc); 314 memp_overflow_check_element_underflow(memp, desc); 315 #endif /* MEMP_OVERFLOW_CHECK */ 316 317 *desc->tab = memp->next; 318 #if MEMP_OVERFLOW_CHECK 319 memp->next = NULL; 320 #endif /* MEMP_OVERFLOW_CHECK */ 321 #endif /* !MEMP_MEM_MALLOC */ 322 #if MEMP_OVERFLOW_CHECK 323 memp->file = file; 324 memp->line = line; 325 #if MEMP_MEM_MALLOC 326 memp_overflow_init_element(memp, desc); 327 #endif /* MEMP_MEM_MALLOC */ 328 #endif /* MEMP_OVERFLOW_CHECK */ 329 LWIP_ASSERT("memp_malloc: memp properly aligned", 330 ((mem_ptr_t)memp % MEM_ALIGNMENT) == 0); 331 #if MEMP_STATS 332 desc->stats->used++; 333 if (desc->stats->used > desc->stats->max) { 334 desc->stats->max = desc->stats->used; 335 } 336 #endif 337 SYS_ARCH_UNPROTECT(old_level); 338 /* cast through u8_t* to get rid of alignment warnings */ 339 return ((u8_t*)memp + MEMP_SIZE); 340 } else { 341 LWIP_DEBUGF(MEMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("memp_malloc: out of memory in pool %s\n", desc->desc)); 342 #if MEMP_STATS 343 desc->stats->err++; 344 #endif 345 } 346 347 SYS_ARCH_UNPROTECT(old_level); 348 return NULL; 349 } 350 351 /** 352 * Get an element from a custom pool. 353 * 354 * @param desc the pool to get an element from 355 * 356 * @return a pointer to the allocated memory or a NULL pointer on error 357 */ 358 void * 359 #if !MEMP_OVERFLOW_CHECK 360 memp_malloc_pool(const struct memp_desc *desc) 361 #else 362 memp_malloc_pool_fn(const struct memp_desc *desc, const char* file, const int line) 363 #endif 364 { 365 LWIP_ASSERT("invalid pool desc", desc != NULL); 366 if (desc == NULL) { 367 return NULL; 368 } 369 370 #if !MEMP_OVERFLOW_CHECK 371 return do_memp_malloc_pool(desc); 372 #else 373 return do_memp_malloc_pool_fn(desc, file, line); 374 #endif 375 } 376 377 /** 378 * Get an element from a specific pool. 379 * 380 * @param type the pool to get an element from 381 * 382 * @return a pointer to the allocated memory or a NULL pointer on error 383 */ 384 void * 385 #if !MEMP_OVERFLOW_CHECK 386 memp_malloc(memp_t type) 387 #else 388 memp_malloc_fn(memp_t type, const char* file, const int line) 389 #endif 390 { 391 void *memp; 392 LWIP_ERROR("memp_malloc: type < MEMP_MAX", (type < MEMP_MAX), return NULL;); 393 394 #if MEMP_OVERFLOW_CHECK >= 2 395 memp_overflow_check_all(); 396 #endif /* MEMP_OVERFLOW_CHECK >= 2 */ 397 398 #if !MEMP_OVERFLOW_CHECK 399 memp = do_memp_malloc_pool(memp_pools[type]); 400 #else 401 memp = do_memp_malloc_pool_fn(memp_pools[type], file, line); 402 #endif 403 404 return memp; 405 } 406 407 static void 408 do_memp_free_pool(const struct memp_desc* desc, void *mem) 409 { 410 struct memp *memp; 411 SYS_ARCH_DECL_PROTECT(old_level); 412 413 LWIP_ASSERT("memp_free: mem properly aligned", 414 ((mem_ptr_t)mem % MEM_ALIGNMENT) == 0); 415 416 /* cast through void* to get rid of alignment warnings */ 417 memp = (struct memp *)(void *)((u8_t*)mem - MEMP_SIZE); 418 419 SYS_ARCH_PROTECT(old_level); 420 421 #if MEMP_OVERFLOW_CHECK == 1 422 memp_overflow_check_element_overflow(memp, desc); 423 memp_overflow_check_element_underflow(memp, desc); 424 #endif /* MEMP_OVERFLOW_CHECK */ 425 426 #if MEMP_STATS 427 desc->stats->used--; 428 #endif 429 430 #if MEMP_MEM_MALLOC 431 LWIP_UNUSED_ARG(desc); 432 SYS_ARCH_UNPROTECT(old_level); 433 mem_free(memp); 434 #else /* MEMP_MEM_MALLOC */ 435 memp->next = *desc->tab; 436 *desc->tab = memp; 437 438 #if MEMP_SANITY_CHECK 439 LWIP_ASSERT("memp sanity", memp_sanity(desc)); 440 #endif /* MEMP_SANITY_CHECK */ 441 442 SYS_ARCH_UNPROTECT(old_level); 443 #endif /* !MEMP_MEM_MALLOC */ 444 } 445 446 /** 447 * Put a custom pool element back into its pool. 448 * 449 * @param desc the pool where to put mem 450 * @param mem the memp element to free 451 */ 452 void 453 memp_free_pool(const struct memp_desc* desc, void *mem) 454 { 455 LWIP_ASSERT("invalid pool desc", desc != NULL); 456 if ((desc == NULL) || (mem == NULL)) { 457 return; 458 } 459 460 do_memp_free_pool(desc, mem); 461 } 462 463 /** 464 * Put an element back into its pool. 465 * 466 * @param type the pool where to put mem 467 * @param mem the memp element to free 468 */ 469 void 470 memp_free(memp_t type, void *mem) 471 { 472 #ifdef LWIP_HOOK_MEMP_AVAILABLE 473 struct memp *old_first; 474 #endif 475 476 LWIP_ERROR("memp_free: type < MEMP_MAX", (type < MEMP_MAX), return;); 477 478 if (mem == NULL) { 479 return; 480 } 481 482 #if MEMP_OVERFLOW_CHECK >= 2 483 memp_overflow_check_all(); 484 #endif /* MEMP_OVERFLOW_CHECK >= 2 */ 485 486 #ifdef LWIP_HOOK_MEMP_AVAILABLE 487 old_first = *memp_pools[type]->tab; 488 #endif 489 490 do_memp_free_pool(memp_pools[type], mem); 491 492 #ifdef LWIP_HOOK_MEMP_AVAILABLE 493 if (old_first == NULL) { 494 LWIP_HOOK_MEMP_AVAILABLE(type); 495 } 496 #endif 497 } 498