Skip to content

Commit 18d8086

Browse files
JacobBarthelmehJacobBarthelmeh
committed
add lean static memory build
1 parent 200f309 commit 18d8086

3 files changed

Lines changed: 153 additions & 27 deletions

File tree

‎wolfcrypt/src/memory.c‎

Lines changed: 123 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -514,20 +514,39 @@ void* wolfSSL_Realloc(void *ptr, size_t size)
514514
struct wc_Memory {
515515
byte* buffer;
516516
struct wc_Memory* next;
517+
#ifdef WOLFSSL_LEAN_STATIC_MEMORY
518+
/* lean static memory is assumed to be under 65k */
519+
word16 sz;
520+
#else
517521
word32 sz;
522+
#endif
523+
#ifdef WOLFSSL_DEBUG_MEMORY
524+
word16 szUsed;
525+
#endif
518526
};
519527

520528

529+
#ifdef WOLFSSL_DEBUG_MEMORY_CALLBACK
530+
static DebugMemoryCb DebugCb = NULL;
531+
532+
/* Used to set a debug memory callback. Helpful in cases where
533+
* printf is not available. */
534+
void wolfSSL_SetDebugCallback(DebugMemoryCb in)
535+
{
536+
DebugCb = in;
537+
}
538+
#endif
539+
521540
/* returns amount of memory used on success. On error returns negative value
522541
wc_Memory** list is the list that new buckets are prepended to
523542
*/
524543
static int wc_create_memory_buckets(byte* buffer, word32 bufSz,
525-
word32 buckSz, word32 buckNum, wc_Memory** list) {
526-
word32 i;
544+
word32 buckSz, byte buckNum, wc_Memory** list) {
527545
byte* pt = buffer;
528546
int ret = 0;
529-
word32 memSz = (word32)sizeof(wc_Memory);
530-
word32 padSz = -(int)memSz & (WOLFSSL_STATIC_ALIGN - 1);
547+
byte memSz = (byte)sizeof(wc_Memory);
548+
word16 padSz = -(int)memSz & (WOLFSSL_STATIC_ALIGN - 1);
549+
word16 i;
531550

532551
/* if not enough space available for bucket size then do not try */
533552
if (buckSz + memSz + padSz > bufSz) {
@@ -542,6 +561,12 @@ static int wc_create_memory_buckets(byte* buffer, word32 bufSz,
542561
mem->buffer = (byte*)pt + padSz + memSz;
543562
mem->next = NULL;
544563

564+
#ifdef WOLFSSL_DEBUG_MEMORY_CALLBACK
565+
if (DebugCb) {
566+
DebugCb(buckSz, buckSz, WOLFSSL_DEBUG_MEMORY_INIT, 0);
567+
}
568+
#endif
569+
545570
/* add the newly created struct to front of list */
546571
if (*list == NULL) {
547572
*list = mem;
@@ -568,8 +593,8 @@ static int wc_partition_static_memory(byte* buffer, word32 sz, int flag,
568593
word32 ava = sz;
569594
byte* pt = buffer;
570595
int ret = 0;
571-
word32 memSz = (word32)sizeof(wc_Memory);
572-
word32 padSz = -(int)memSz & (WOLFSSL_STATIC_ALIGN - 1);
596+
byte memSz = (word32)sizeof(wc_Memory);
597+
byte padSz = -(int)memSz & (WOLFSSL_STATIC_ALIGN - 1);
573598

574599
WOLFSSL_ENTER("wc_partition_static_memory");
575600

@@ -631,15 +656,25 @@ static int wc_partition_static_memory(byte* buffer, word32 sz, int flag,
631656
static int wc_init_memory_heap(WOLFSSL_HEAP* heap, unsigned int listSz,
632657
const unsigned int* sizeList, const unsigned int* distList)
633658
{
659+
word16 i;
660+
634661
XMEMSET(heap, 0, sizeof(WOLFSSL_HEAP));
635662

636-
XMEMCPY(heap->sizeList, sizeList, listSz * sizeof(sizeList[0]));
637-
XMEMCPY(heap->distList, distList, listSz * sizeof(distList[0]));
663+
/* avoid XMEMCPY for LEAN static memory build */
664+
for (i = 0; i < listSz; i++) {
665+
heap->sizeList[i] = sizeList[i];
666+
}
667+
668+
for (i = 0; i < listSz; i++) {
669+
heap->distList[i] = distList[i];
670+
}
638671

672+
#ifndef SINGLE_THREADED
639673
if (wc_InitMutex(&(heap->memory_mutex)) != 0) {
640674
WOLFSSL_MSG("Error creating heap memory mutex");
641675
return BAD_MUTEX_E;
642676
}
677+
#endif
643678

644679
return 0;
645680
}
@@ -651,7 +686,7 @@ int wc_LoadStaticMemory_ex(WOLFSSL_HEAP_HINT** pHint,
651686
{
652687
WOLFSSL_HEAP* heap = NULL;
653688
WOLFSSL_HEAP_HINT* hint = NULL;
654-
word32 idx = 0;
689+
word16 idx = 0;
655690
int ret;
656691

657692
WOLFSSL_ENTER("wc_LoadStaticMemory_ex");
@@ -704,15 +739,16 @@ int wc_LoadStaticMemory_ex(WOLFSSL_HEAP_HINT** pHint,
704739
return MEMORY_E;
705740
}
706741

742+
#ifndef WOLFSSL_LEAN_STATIC_MEMORY
707743
/* determine what max applies too */
708744
if ((flag & WOLFMEM_IO_POOL) || (flag & WOLFMEM_IO_POOL_FIXED)) {
709745
heap->maxIO = maxSz;
710746
}
711747
else { /* general memory used in handshakes */
712748
heap->maxHa = maxSz;
713749
}
714-
715750
heap->flag |= flag;
751+
#endif
716752
*pHint = hint;
717753

718754
return 0;
@@ -721,8 +757,13 @@ int wc_LoadStaticMemory_ex(WOLFSSL_HEAP_HINT** pHint,
721757
int wc_LoadStaticMemory(WOLFSSL_HEAP_HINT** pHint,
722758
unsigned char* buf, unsigned int sz, int flag, int maxSz)
723759
{
760+
#ifdef WOLFSSL_LEAN_STATIC_PSK
761+
word16 sizeList[WOLFMEM_DEF_BUCKETS] = { WOLFMEM_BUCKETS };
762+
byte distList[WOLFMEM_DEF_BUCKETS] = { WOLFMEM_DIST };
763+
#else
724764
word32 sizeList[WOLFMEM_DEF_BUCKETS] = { WOLFMEM_BUCKETS };
725765
word32 distList[WOLFMEM_DEF_BUCKETS] = { WOLFMEM_DIST };
766+
#endif
726767
int ret = 0;
727768

728769
WOLFSSL_ENTER("wc_LoadStaticMemory");
@@ -742,7 +783,7 @@ void wc_UnloadStaticMemory(WOLFSSL_HEAP_HINT* heap)
742783
}
743784
}
744785

745-
786+
#ifndef WOLFSSL_LEAN_STATIC_MEMORY
746787
/* returns the size of management memory needed for each bucket.
747788
* This is memory that is used to keep track of and align memory buckets. */
748789
int wolfSSL_MemoryPaddingSz(void)
@@ -782,6 +823,7 @@ int wolfSSL_StaticBufferSz_ex(unsigned int listSz,
782823
ava--;
783824
}
784825

826+
#ifndef WOLFSSL_LEAN_STATIC_MEMORY
785827
/* creating only IO buffers from memory passed in, max TLS is 16k */
786828
if (flag & WOLFMEM_IO_POOL || flag & WOLFMEM_IO_POOL_FIXED) {
787829
if (ava < (memSz + padSz + WOLFMEM_IO_SZ)) {
@@ -790,7 +832,9 @@ int wolfSSL_StaticBufferSz_ex(unsigned int listSz,
790832

791833
ava = ava % (memSz + padSz + WOLFMEM_IO_SZ);
792834
}
793-
else {
835+
else
836+
#endif
837+
{
794838
int i, k;
795839

796840
if (ava < (sizeList[0] + padSz + memSz)) {
@@ -897,6 +941,7 @@ int wolfSSL_GetMemStats(WOLFSSL_HEAP* heap, WOLFSSL_MEM_STATS* stats)
897941

898942
return 1;
899943
}
944+
#endif /* !WOLFSSL_LEAN_STATIC_MEMORY */
900945

901946

902947
/* global heap hint to fall back on when no heap hint is passed to
@@ -987,11 +1032,14 @@ void* wolfSSL_Malloc(size_t size, void* heap, int type)
9871032
}
9881033
mem = hint->memory;
9891034

1035+
#ifndef SINGLE_THREADED
9901036
if (wc_LockMutex(&(mem->memory_mutex)) != 0) {
9911037
WOLFSSL_MSG("Bad memory_mutex lock");
9921038
return NULL;
9931039
}
1040+
#endif
9941041

1042+
#ifndef WOLFSSL_LEAN_STATIC_MEMORY
9951043
/* case of using fixed IO buffers */
9961044
if (mem->flag & WOLFMEM_IO_POOL_FIXED &&
9971045
(type == DYNAMIC_TYPE_OUT_BUFFER ||
@@ -1003,7 +1051,10 @@ void* wolfSSL_Malloc(size_t size, void* heap, int type)
10031051
pt = hint->inBuf;
10041052
}
10051053
}
1006-
else {
1054+
else
1055+
#endif
1056+
{
1057+
#ifndef WOLFSSL_LEANPSK
10071058
/* check if using IO pool flag */
10081059
if (mem->flag & WOLFMEM_IO_POOL &&
10091060
(type == DYNAMIC_TYPE_OUT_BUFFER ||
@@ -1013,6 +1064,7 @@ void* wolfSSL_Malloc(size_t size, void* heap, int type)
10131064
mem->io = pt->next;
10141065
}
10151066
}
1067+
#endif
10161068

10171069
/* general static memory */
10181070
if (pt == NULL) {
@@ -1035,14 +1087,21 @@ void* wolfSSL_Malloc(size_t size, void* heap, int type)
10351087
}
10361088

10371089
if (pt != NULL) {
1038-
mem->inUse += pt->sz;
1090+
#ifndef WOLFSSL_LEAN_STATIC_MEMORY
10391091
mem->alloc += 1;
1092+
#endif
10401093
res = pt->buffer;
10411094

10421095
#ifdef WOLFSSL_DEBUG_MEMORY
1043-
fprintf(stderr, "Alloc: %p -> %u at %s:%d\n", pt->buffer, pt->sz, func, line);
1096+
pt->szUsed = size;
1097+
fprintf(stderr, "Alloc: %p -> %lu at %s:%d\n", pt->buffer, size, func, line);
10441098
#endif
1045-
1099+
#ifdef WOLFSSL_DEBUG_MEMORY_CALLBACK
1100+
if (DebugCb) {
1101+
DebugCb(size, pt->sz, WOLFSSL_DEBUG_MEMORY_ALLOC, type);
1102+
}
1103+
#endif
1104+
#ifndef WOLFSSL_LEAN_STATIC_MEMORY
10461105
/* keep track of connection statistics if flag is set */
10471106
if (mem->flag & WOLFMEM_TRACK_STATS) {
10481107
WOLFSSL_MEM_CONN_STATS* stats = hint->stats;
@@ -1058,16 +1117,24 @@ void* wolfSSL_Malloc(size_t size, void* heap, int type)
10581117
stats->totalAlloc++;
10591118
}
10601119
}
1120+
#endif
10611121
}
10621122
else {
10631123
WOLFSSL_MSG("ERROR ran out of static memory");
1124+
res = NULL;
10641125
#ifdef WOLFSSL_DEBUG_MEMORY
10651126
fprintf(stderr, "Looking for %lu bytes at %s:%d\n", (unsigned long) size, func,
10661127
line);
10671128
#endif
1129+
#ifdef WOLFSSL_DEBUG_MEMORY_CALLBACK
1130+
if (DebugCb) {
1131+
DebugCb(size, 0, WOLFSSL_DEBUG_MEMORY_FAIL, type);
1132+
}
1133+
#endif
10681134
}
1069-
1135+
#ifndef SINGLE_THREADED
10701136
wc_UnLockMutex(&(mem->memory_mutex));
1137+
#endif
10711138
}
10721139

10731140
#ifdef WOLFSSL_MALLOC_CHECK
@@ -1148,11 +1215,14 @@ void wolfSSL_Free(void *ptr, void* heap, int type)
11481215

11491216
/* get memory struct and add it to available list */
11501217
pt = (wc_Memory*)((byte*)ptr - sizeof(wc_Memory) - padSz);
1218+
#ifndef SINGLE_THREADED
11511219
if (wc_LockMutex(&(mem->memory_mutex)) != 0) {
11521220
WOLFSSL_MSG("Bad memory_mutex lock");
11531221
return;
11541222
}
1223+
#endif
11551224

1225+
#ifndef WOLFSSL_LEAN_STATIC_MEMORY
11561226
/* case of using fixed IO buffers */
11571227
if (mem->flag & WOLFMEM_IO_POOL_FIXED &&
11581228
(type == DYNAMIC_TYPE_OUT_BUFFER ||
@@ -1166,22 +1236,38 @@ void wolfSSL_Free(void *ptr, void* heap, int type)
11661236
pt->next = mem->io;
11671237
mem->io = pt;
11681238
}
1169-
else { /* general memory free */
1239+
else
1240+
#endif
1241+
{ /* general memory free */
11701242
for (i = 0; i < WOLFMEM_MAX_BUCKETS; i++) {
11711243
if (pt->sz == mem->sizeList[i]) {
11721244
pt->next = mem->ava[i];
11731245
mem->ava[i] = pt;
1246+
1247+
#ifdef WOLFSSL_DEBUG_MEMORY_CALLBACK
1248+
if (DebugCb) {
1249+
#ifdef WOLFSSL_DEBUG_MEMORY
1250+
DebugCb(pt->szUsed, pt->sz, WOLFSSL_DEBUG_MEMORY_FREE, type);
1251+
#else
1252+
DebugCb(pt->sz, pt->sz, WOLFSSL_DEBUG_MEMORY_FREE, type);
1253+
#endif
1254+
}
1255+
#endif
11741256
break;
11751257
}
11761258
}
11771259
}
1260+
#ifndef WOLFSSL_LEAN_STATIC_MEMORY
11781261
mem->inUse -= pt->sz;
11791262
mem->frAlc += 1;
1263+
#endif
11801264

11811265
#ifdef WOLFSSL_DEBUG_MEMORY
1182-
fprintf(stderr, "Free: %p -> %u at %s:%d\n", pt->buffer, pt->sz, func, line);
1266+
fprintf (stderr, "Free: %p -> %u at %s:%d\n", pt->buffer,
1267+
pt->szUsed, func, line);
11831268
#endif
11841269

1270+
#ifndef WOLFSSL_LEAN_STATIC_MEMORY
11851271
/* keep track of connection statistics if flag is set */
11861272
if (mem->flag & WOLFMEM_TRACK_STATS) {
11871273
WOLFSSL_MEM_CONN_STATS* stats = hint->stats;
@@ -1200,7 +1286,10 @@ void wolfSSL_Free(void *ptr, void* heap, int type)
12001286
stats->totalFr++;
12011287
}
12021288
}
1289+
#endif
1290+
#ifndef SINGLE_THREADED
12031291
wc_UnLockMutex(&(mem->memory_mutex));
1292+
#endif
12041293
}
12051294
}
12061295

@@ -1209,6 +1298,7 @@ void wolfSSL_Free(void *ptr, void* heap, int type)
12091298
(void)type;
12101299
}
12111300

1301+
#ifndef WOLFSSL_NO_REALLOC
12121302
#ifdef WOLFSSL_DEBUG_MEMORY
12131303
void* wolfSSL_Realloc(void *ptr, size_t size, void* heap, int type, const char* func, unsigned int line)
12141304
#else
@@ -1256,11 +1346,12 @@ void* wolfSSL_Realloc(void *ptr, size_t size, void* heap, int type)
12561346
return wolfSSL_Malloc(size, heap, type);
12571347
#endif
12581348
}
1259-
1349+
#ifndef SINGLE_THREADED
12601350
if (wc_LockMutex(&(mem->memory_mutex)) != 0) {
12611351
WOLFSSL_MSG("Bad memory_mutex lock");
12621352
return NULL;
12631353
}
1354+
#endif
12641355

12651356
/* case of using fixed IO buffers or IO pool */
12661357
if (((mem->flag & WOLFMEM_IO_POOL)||(mem->flag & WOLFMEM_IO_POOL_FIXED))
@@ -1287,30 +1378,40 @@ void* wolfSSL_Realloc(void *ptr, size_t size, void* heap, int type)
12871378
}
12881379

12891380
if (pt != NULL && res == NULL) {
1381+
word32 prvSz;
1382+
12901383
res = pt->buffer;
12911384

12921385
/* copy over original information and free ptr */
1293-
word32 prvSz = ((wc_Memory*)((byte*)ptr - padSz -
1386+
prvSz = ((wc_Memory*)((byte*)ptr - padSz -
12941387
sizeof(wc_Memory)))->sz;
12951388
prvSz = (prvSz > pt->sz)? pt->sz: prvSz;
12961389
XMEMCPY(pt->buffer, ptr, prvSz);
1390+
#ifndef WOLFSSL_LEAN_STATIC_MEMORY
12971391
mem->inUse += pt->sz;
12981392
mem->alloc += 1;
1393+
#endif
12991394

13001395
/* free memory that was previously being used */
1396+
#ifndef SINGLE_THREADED
13011397
wc_UnLockMutex(&(mem->memory_mutex));
1398+
#endif
13021399
wolfSSL_Free(ptr, heap, type
13031400
#ifdef WOLFSSL_DEBUG_MEMORY
13041401
, func, line
13051402
#endif
13061403
);
1404+
#ifndef SINGLE_THREADED
13071405
if (wc_LockMutex(&(mem->memory_mutex)) != 0) {
13081406
WOLFSSL_MSG("Bad memory_mutex lock");
13091407
return NULL;
13101408
}
1409+
#endif
13111410
}
13121411
}
1412+
#ifndef SINGLE_THREADED
13131413
wc_UnLockMutex(&(mem->memory_mutex));
1414+
#endif
13141415
}
13151416

13161417
#ifdef WOLFSSL_MALLOC_CHECK
@@ -1327,7 +1428,7 @@ void* wolfSSL_Realloc(void *ptr, size_t size, void* heap, int type)
13271428
return res;
13281429
}
13291430
#endif /* WOLFSSL_STATIC_MEMORY */
1330-
1431+
#endif /* WOLFSSL_NO_REALLOC */
13311432
#endif /* USE_WOLFSSL_MEMORY */
13321433

13331434

0 commit comments

Comments
 (0)