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