/* mem_track.h

*

* Copyright (C) 2006-2025 wolfSSL Inc.

*

* This file is part of wolfSSL.

*

* wolfSSL is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 3 of the License, or

* (at your option) any later version.

*

* wolfSSL is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA

*/

/* Memory and stack use tracking */

#ifndef WOLFSSL_MEM_TRACK_H

#define WOLFSSL_MEM_TRACK_H

/* The memory tracker overrides the wolfSSL memory callback system and uses a

* static to track the total, peak and currently allocated bytes.

*

* If you are already using the memory callbacks then enabling this will

* override the memory callbacks and prevent your memory callbacks from

* working. This assumes malloc() and free() are available. Feel free to

* customize this for your needs.

* The enable this feature define the following:

* #define USE_WOLFSSL_MEMORY

* #define WOLFSSL_TRACK_MEMORY

*

* On startup call:

* InitMemoryTracker();

*

* When ready to dump the memory report call:

* ShowMemoryTracker();

*

* Report example:

* total Allocs = 228

* total Bytes = 93442

* peak Bytes = 8840

* current Bytes = 0

*

*

* You can also:

* #define WOLFSSL_DEBUG_MEMORY

*

* To print every alloc/free along with the function and line number.

* Example output:

* Alloc: 0x7fa14a500010 -> 120 at wc_InitRng:496

* Free: 0x7fa14a500010 -> 120 at wc_FreeRng:606

*/

#include "wolfssl/wolfcrypt/settings.h"

#include "wolfssl/wolfcrypt/types.h"

#include "wolfssl/wolfcrypt/logging.h"

#include "wolfssl/wolfcrypt/error-crypt.h"

#include "wolfssl/wolfcrypt/memory.h"

#if defined(WOLFSSL_TRACK_MEMORY) || defined(HAVE_STACK_SIZE) || \

defined(HAVE_STACK_SIZE_VERBOSE)

#ifdef NO_STDIO_FILESYSTEM

#define wc_mem_printf(...) printf(__VA_ARGS__)

#else

#include <stdio.h>

#define wc_mem_printf(...) fprintf(stderr, __VA_ARGS__)

#endif

#endif

/* Track Memory */

#if defined(WOLFSSL_TRACK_MEMORY) && defined(USE_WOLFSSL_MEMORY) && \

!defined(WOLFSSL_STATIC_MEMORY)

#define DO_MEM_STATS

#if (defined(__linux__) && !defined(WOLFSSL_KERNEL_MODE)) || defined(__MACH__)

#define DO_MEM_LIST

#endif

typedef struct memoryStats {

long totalAllocs; /* number of allocations */

long totalDeallocs; /* number of deallocations */

long totalBytes; /* total number of bytes allocated */

long peakBytes; /* concurrent max bytes */

long currentBytes; /* total current bytes in use */

#ifdef WOLFSSL_TRACK_MEMORY_VERBOSE

long peakAllocsTripOdometer; /* peak number of concurrent allocations,

* subject to reset by

* wolfCrypt_heap_peak_checkpoint()

*/

long peakBytesTripOdometer; /* peak concurrent bytes, subject to reset

* by wolfCrypt_heap_peak_checkpoint()

*/

#endif

} memoryStats;

typedef struct memHint {

size_t thisSize; /* size of this memory */

#ifdef DO_MEM_LIST

struct memHint* next;

struct memHint* prev;

#ifdef WOLFSSL_DEBUG_MEMORY

const char* func;

unsigned int line;

#endif

#endif

void* thisMemory; /* actual memory for user */

} memHint;

typedef struct memoryTrack {

union {

memHint hint;

/* make sure we have strong alignment */

byte alignit[sizeof(memHint) + ((16-1) & ~(16-1))];

} u;

} memoryTrack;

#ifdef DO_MEM_LIST

/* track allocations and report at end */

typedef struct memoryList {

memHint* head;

memHint* tail;

word32 count;

} memoryList;

#endif

static memoryStats ourMemStats;

#ifdef DO_MEM_LIST

#include <pthread.h>

static memoryList ourMemList;

static pthread_mutex_t memLock = PTHREAD_MUTEX_INITIALIZER;

#endif

#ifdef WOLFSSL_DEBUG_MEMORY

static WC_INLINE void* TrackMalloc(size_t sz, const char* func,

unsigned int line)

#else

static WC_INLINE void* TrackMalloc(size_t sz)

#endif

{

memoryTrack* mt;

memHint* header;

if (sz == 0)

return NULL;

#ifdef FREERTOS

mt = (memoryTrack*)pvPortMalloc(sizeof(memoryTrack) + sz); /* native heap */

#else

mt = (memoryTrack*)malloc(sizeof(memoryTrack) + sz); /* native heap */

#endif

if (mt == NULL)

return NULL;

header = &mt->u.hint;

header->thisSize = sz;

header->thisMemory = (byte*)mt + sizeof(memoryTrack);

#ifdef WOLFSSL_DEBUG_MEMORY

#ifdef WOLFSSL_DEBUG_MEMORY_PRINT

wc_mem_printf("Alloc: %p -> %u at %s:%d\n",

header->thisMemory, (word32)sz, func, line);

#else

(void)func;

(void)line;

#endif

#endif

#if !defined(SINGLE_THREADED) && (defined(DO_MEM_LIST) || defined(DO_MEM_STATS))

if (pthread_mutex_lock(&memLock) == 0)

{

#endif

#ifdef DO_MEM_STATS

ourMemStats.totalAllocs++;

ourMemStats.totalBytes += sz;

ourMemStats.currentBytes += sz;

#ifdef WOLFSSL_TRACK_MEMORY_VERBOSE

if (ourMemStats.peakAllocsTripOdometer < ourMemStats.totalAllocs -

ourMemStats.totalDeallocs) {

ourMemStats.peakAllocsTripOdometer = ourMemStats.totalAllocs -

ourMemStats.totalDeallocs;

}

if (ourMemStats.peakBytesTripOdometer < ourMemStats.currentBytes)

#endif

{

#ifdef WOLFSSL_TRACK_MEMORY_VERBOSE

ourMemStats.peakBytesTripOdometer = ourMemStats.currentBytes;

#endif

if (ourMemStats.currentBytes > ourMemStats.peakBytes)

ourMemStats.peakBytes = ourMemStats.currentBytes;

}

#endif /* DO_MEM_STATS */

#ifdef DO_MEM_LIST

#ifdef WOLFSSL_DEBUG_MEMORY

header->func = func;

header->line = line;

#endif

/* Setup event */

header->next = NULL;

if (ourMemList.tail == NULL) {

ourMemList.head = header;

header->prev = NULL;

}

else {

ourMemList.tail->next = header;

header->prev = ourMemList.tail;

}

ourMemList.tail = header; /* add to the end either way */

ourMemList.count++;

#endif

#if !defined(SINGLE_THREADED) && (defined(DO_MEM_LIST) || defined(DO_MEM_STATS))

pthread_mutex_unlock(&memLock);

}

#endif /* DO_MEM_LIST */

return header->thisMemory;

}

#ifdef WOLFSSL_DEBUG_MEMORY

static WC_INLINE void TrackFree(void* ptr, const char* func, unsigned int line)

#else

static WC_INLINE void TrackFree(void* ptr)

#endif

{

memoryTrack* mt;

memHint* header;

size_t sz;

if (ptr == NULL) {

return;

}

mt = (memoryTrack*)((byte*)ptr - sizeof(memoryTrack));

header = &mt->u.hint;

sz = header->thisSize;

#if !defined(SINGLE_THREADED) && (defined(DO_MEM_LIST) || defined(DO_MEM_STATS))

if (pthread_mutex_lock(&memLock) == 0)

{

#endif

#ifdef DO_MEM_STATS

ourMemStats.currentBytes -= header->thisSize;

ourMemStats.totalDeallocs++;

#endif

#ifdef DO_MEM_LIST

if (header == ourMemList.head && header == ourMemList.tail) {

ourMemList.head = NULL;

ourMemList.tail = NULL;

}

else if (header == ourMemList.head) {

ourMemList.head = header->next;

ourMemList.head->prev = NULL;

}

else if (header == ourMemList.tail) {

ourMemList.tail = header->prev;

ourMemList.tail->next = NULL;

}

else {

memHint* next = header->next;

memHint* prev = header->prev;

if (next)

next->prev = prev;

if (prev)

prev->next = next;

}

ourMemList.count--;

#endif

#if !defined(SINGLE_THREADED) && (defined(DO_MEM_LIST) || defined(DO_MEM_STATS))

pthread_mutex_unlock(&memLock);

}

#endif

#ifdef WOLFSSL_DEBUG_MEMORY

#ifdef WOLFSSL_DEBUG_MEMORY_PRINT

wc_mem_printf("Free: %p -> %u at %s:%d\n", ptr, (word32)sz, func, line);

#else

(void)func;

(void)line;

#endif

#endif

(void)sz;

#ifdef FREERTOS

vPortFree(mt); /* native heap */

#else

free(mt); /* native heap */

#endif

}

#ifdef WOLFSSL_DEBUG_MEMORY

static WC_INLINE void* TrackRealloc(void* ptr, size_t sz, const char* func,

unsigned int line)

#else

static WC_INLINE void* TrackRealloc(void* ptr, size_t sz)

#endif

{

#ifdef WOLFSSL_DEBUG_MEMORY

void* ret = TrackMalloc(sz, func, line);

#else

void* ret = TrackMalloc(sz);

#endif

if (ptr) {

/* if realloc is bigger, don't overread old ptr */

memoryTrack* mt;

memHint* header;

mt = (memoryTrack*)((byte*)ptr - sizeof(memoryTrack));

header = &mt->u.hint;

if (header->thisSize < sz)

sz = header->thisSize;

}

if (ret && ptr)

XMEMCPY(ret, ptr, sz);

if (ret) {

#ifdef WOLFSSL_DEBUG_MEMORY

TrackFree(ptr, func, line);

#else

TrackFree(ptr);

#endif

}

return ret;

}

static wolfSSL_Malloc_cb mfDefault = NULL;

static wolfSSL_Free_cb ffDefault = NULL;

static wolfSSL_Realloc_cb rfDefault = NULL;

static WC_INLINE int InitMemoryTracker(void)

{

int ret;

ret = wolfSSL_GetAllocators(&mfDefault, &ffDefault, &rfDefault);

if (ret < 0) {

wc_mem_printf("wolfSSL GetAllocators failed to get the defaults\n");

}

ret = wolfSSL_SetAllocators(TrackMalloc, TrackFree, TrackRealloc);

if (ret < 0) {

wc_mem_printf("wolfSSL SetAllocators failed for track memory\n");

return ret;

}

#ifdef DO_MEM_LIST

if (pthread_mutex_lock(&memLock) == 0)

#endif

{

#ifdef DO_MEM_STATS

ourMemStats.totalAllocs = 0;

ourMemStats.totalDeallocs = 0;

ourMemStats.totalBytes = 0;

ourMemStats.peakBytes = 0;

ourMemStats.currentBytes = 0;

#ifdef WOLFSSL_TRACK_MEMORY_VERBOSE

ourMemStats.peakAllocsTripOdometer = 0;

ourMemStats.peakBytesTripOdometer = 0;

#endif

#endif /* DO_MEM_STATS */

#ifdef DO_MEM_LIST

XMEMSET(&ourMemList, 0, sizeof(ourMemList));

pthread_mutex_unlock(&memLock);

#endif

}

return ret;

}

static WC_INLINE void ShowMemoryTracker(void)

{

#ifdef DO_MEM_LIST

if (pthread_mutex_lock(&memLock) == 0)

#endif

{

#ifdef DO_MEM_STATS

wc_mem_printf("total Allocs = %9ld\n", ourMemStats.totalAllocs);

wc_mem_printf("total Deallocs = %9ld\n", ourMemStats.totalDeallocs);

wc_mem_printf("total Bytes = %9ld\n", ourMemStats.totalBytes);

wc_mem_printf("peak Bytes = %9ld\n", ourMemStats.peakBytes);

wc_mem_printf("current Bytes = %9ld\n", ourMemStats.currentBytes);

#endif

#ifdef DO_MEM_LIST

if (ourMemList.count > 0) {

/* print list of allocations */

memHint* header;

for (header = ourMemList.head;

header != NULL;

header = header->next) {

#ifdef WOLFSSL_DEBUG_MEMORY

wc_mem_printf("Leak: Ptr %p, Size %u, Func %s, Line %d\n",

(byte*)header + sizeof(memHint),

(unsigned int)header->thisSize, header->func, header->line);

#else

wc_mem_printf("Leak: Ptr %p, Size %u\n",

(byte*)header + sizeof(memHint),

(unsigned int)header->thisSize);

#endif

}

}

pthread_mutex_unlock(&memLock);

#endif

}

}

static WC_INLINE int CleanupMemoryTracker(void)

{

/* restore default allocators */

return wolfSSL_SetAllocators(mfDefault, ffDefault, rfDefault);

}

#endif /* WOLFSSL_TRACK_MEMORY && USE_WOLFSSL_MEMORY && \

!WOLFSSL_STATIC_MEMORY */

#ifdef HAVE_STACK_SIZE

#include <stdio.h>

#ifdef HAVE_PTHREAD

#include <pthread.h>

#include <errno.h>

#include <sched.h>

#include <unistd.h>

#endif

typedef void* (*thread_func)(void* args);

#define STACK_CHECK_VAL 0x01

struct stack_size_debug_context {

unsigned char *myStack;

size_t stackSize;

#ifdef HAVE_STACK_SIZE_VERBOSE

size_t *stackSizeHWM_ptr;

thread_func fn;

void *args;

#endif

};

struct func_args; /* forward declaration */

#ifdef HAVE_STACK_SIZE_VERBOSE

/*

* Allow bare-metal targets to register a statically allocated stack region

* that should be inspected for high water mark usage. The caller is expected

* to invoke this once early during startup, before the stack contains live

* frames, using linker-provided low/high water symbols.

*

* Example (GNU ld symbols) on a downward-growing (ARM Cortex-M) stack:

* extern unsigned char _estack; - one past highest address

* #define WOLFSSL_STACK_BYTES (12 * 1024U)

* StackSizeCheck_SetStackRegion((unsigned char*)(&_estack) -

* WOLFSSL_STACK_BYTES, WOLFSSL_STACK_BYTES, NULL);

* or simply

* STACK_SIZE_CHECK_INIT_TOP(&_estack, WOLFSSL_STACK_BYTES);

*

* The initializer samples the current stack pointer and avoids clobbering

* the live call frames. Call it as early as practical (right after the C

* runtime start-up, with interrupts masked) so that most of the stack can be

* painted with the sentinel before it is used.

*/

static WC_INLINE int StackSizeCheck_SetStackRegion(unsigned char* stackBase,

size_t stackSize, size_t* hwmStorage)

{

volatile unsigned char currentSpVar;

unsigned char* currentSp;

unsigned char* stackTop;

if (stackBase == NULL || stackSize == 0)

return -BAD_FUNC_ARG;

StackSizeCheck_myStack = stackBase;

StackSizeCheck_stackSize = stackSize;

if (hwmStorage != NULL) {

StackSizeCheck_stackSizeHWM_ptr = hwmStorage;

*StackSizeCheck_stackSizeHWM_ptr = 0;

}

else {

StackSizeCheck_stackSizeHWM = 0;

StackSizeCheck_stackSizeHWM_ptr = &StackSizeCheck_stackSizeHWM;

}

stackTop = stackBase + stackSize;

StackSizeCheck_stackOffsetPointer = (void*)stackTop;

currentSp = (unsigned char*)&currentSpVar;

if (currentSp >= stackBase && currentSp <= stackTop) {

size_t lowerSpan = (size_t)(currentSp - stackBase);

size_t upperSpan = (size_t)(stackTop - currentSp);

if (lowerSpan >= upperSpan) {

if (lowerSpan > 0) {

XMEMSET(stackBase, STACK_CHECK_VAL, lowerSpan);

}

}

else {

if (upperSpan > 0) {

XMEMSET(currentSp, STACK_CHECK_VAL, upperSpan);

}

}

}

else {

XMEMSET(StackSizeCheck_myStack, STACK_CHECK_VAL, stackSize);

}

return 0;

}

#ifdef HAVE_STACK_SIZE_VERBOSE

static WC_INLINE int StackSizeCheck_Rebaseline(void)

{

size_t* hwmStore;

if (StackSizeCheck_myStack == NULL || StackSizeCheck_stackSize == 0)

return -BAD_FUNC_ARG;

hwmStore = StackSizeCheck_stackSizeHWM_ptr;

if (hwmStore == NULL || hwmStore == &StackSizeCheck_stackSizeHWM)

hwmStore = NULL;

return StackSizeCheck_SetStackRegion(StackSizeCheck_myStack,

StackSizeCheck_stackSize, hwmStore);

}

#endif

#ifndef STACK_SIZE_CHECK_INIT_REGION

#define STACK_SIZE_CHECK_INIT_REGION(lowAddr, highAddr) \

StackSizeCheck_SetStackRegion((unsigned char*)(lowAddr), \

(size_t)((char*)(highAddr) - (char*)(lowAddr)), NULL)

#endif

#ifndef STACK_SIZE_CHECK_INIT_REGION_EX

#define STACK_SIZE_CHECK_INIT_REGION_EX(lowAddr, highAddr, hwmPtr) \

StackSizeCheck_SetStackRegion((unsigned char*)(lowAddr), \

(size_t)((char*)(highAddr) - (char*)(lowAddr)), (hwmPtr))

#endif

#ifndef STACK_SIZE_CHECK_INIT_TOP

#define STACK_SIZE_CHECK_INIT_TOP(topAddr, sizeBytes) \

StackSizeCheck_SetStackRegion( \

(unsigned char*)((unsigned char*)(topAddr) - (size_t)(sizeBytes)), \

(size_t)(sizeBytes), NULL)

#endif

#ifndef STACK_SIZE_CHECK_INIT_TOP_EX

#define STACK_SIZE_CHECK_INIT_TOP_EX(topAddr, sizeBytes, hwmPtr) \

StackSizeCheck_SetStackRegion( \

(unsigned char*)((unsigned char*)(topAddr) - (size_t)(sizeBytes)), \

(size_t)(sizeBytes), (hwmPtr))

#endif

/* per-subtest stack high water mark tracking.

*

* enable with

*

* ./configure --enable-stacksize=verbose [...]

*/

static void* debug_stack_size_verbose_shim(

struct stack_size_debug_context *shim_args)

{

StackSizeCheck_myStack = shim_args->myStack;

StackSizeCheck_stackSize = shim_args->stackSize;

StackSizeCheck_stackSizeHWM_ptr = shim_args->stackSizeHWM_ptr;

return shim_args->fn(shim_args->args);

}

static WC_INLINE int StackSizeSetOffset(const char *funcname, void *p)

{

if (StackSizeCheck_myStack == NULL)

return -BAD_FUNC_ARG;

StackSizeCheck_stackOffsetPointer = p;

printf("setting stack relative offset reference mark in %s to +%lu\n",

funcname, (unsigned long)((char*)(StackSizeCheck_myStack +

StackSizeCheck_stackSize) - (char *)p));

return 0;

}

static WC_INLINE ssize_t StackSizeHWM(void)

{

size_t i;

ssize_t used;

if (StackSizeCheck_myStack == NULL)

return -BAD_FUNC_ARG;

for (i = 0; i < StackSizeCheck_stackSize; i++) {

if (StackSizeCheck_myStack[i] != STACK_CHECK_VAL) {

break;

}

}

used = StackSizeCheck_stackSize - i;

if ((ssize_t)*StackSizeCheck_stackSizeHWM_ptr < used)

*StackSizeCheck_stackSizeHWM_ptr = used;

return used;

}

static WC_INLINE ssize_t StackSizeHWM_OffsetCorrected(void)

{

ssize_t used = StackSizeHWM();

if (used < 0)

return used;

if (StackSizeCheck_stackOffsetPointer) {

used -= (ssize_t)(((char *)StackSizeCheck_myStack +

StackSizeCheck_stackSize) -

(char *)StackSizeCheck_stackOffsetPointer);

}

return used;

}

static

#ifdef __GNUC__

__attribute__((unused)) __attribute__((noinline))

#endif

int StackSizeHWMReset(void)

{

volatile ssize_t i;

if (StackSizeCheck_myStack == NULL)

return -BAD_FUNC_ARG;

for (i = (ssize_t)((char *)&i - (char *)StackSizeCheck_myStack) -

(ssize_t)sizeof(i) - 1; i >= 0; --i) {

StackSizeCheck_myStack[i] = STACK_CHECK_VAL;

}

return 0;

}

#define STACK_SIZE_CHECKPOINT(...) ({ \

ssize_t HWM = StackSizeHWM_OffsetCorrected(); \

__VA_ARGS__; \

printf(" relative stack peak usage = %ld bytes\n", (long int)HWM); \

StackSizeHWMReset(); \

})

#define STACK_SIZE_CHECKPOINT_MSG(msg) ({ \

ssize_t HWM = StackSizeHWM_OffsetCorrected(); \

wc_mem_printf("%ld\t%s\n", (long int)HWM, msg); \

StackSizeHWMReset(); \

})

#define STACK_SIZE_CHECKPOINT_WITH_MAX_CHECK(max, ...) ({ \

ssize_t HWM = StackSizeHWM_OffsetCorrected(); \

int _ret; \

__VA_ARGS__; \

printf(" relative stack peak usage = %ld bytes\n", (long int)HWM); \

_ret = StackSizeHWMReset(); \

if ((max >= 0) && (HWM > (ssize_t)(max))) { \

wc_mem_printf( \

" relative stack usage at %s L%d exceeds designated " \

"max %ld bytes.\n", \

__FILE__, __LINE__, (long int)(max)); \

_ret = -1; \

} \

_ret; \

})

#if defined(__GNUC__) || defined(__clang__)

#define STACK_SIZE_INIT() \

(void)StackSizeSetOffset(__FUNCTION__, __builtin_frame_address(0))

#endif

#endif /* HAVE_STACK_SIZE_VERBOSE */

#ifdef HAVE_PTHREAD

static WC_INLINE int StackSizeCheck(struct func_args* args, thread_func tf)

{

size_t i;

int ret;

void* status;

unsigned char* myStack = NULL;

size_t stackSize = 1024*1024*2;

pthread_attr_t myAttr;

pthread_t threadId;

#ifdef HAVE_STACK_SIZE_VERBOSE

struct stack_size_debug_context shim_args;

#endif

#ifdef PTHREAD_STACK_MIN

if (stackSize < (size_t)PTHREAD_STACK_MIN)

stackSize = PTHREAD_STACK_MIN;

#endif

ret = posix_memalign((void**)&myStack, sysconf(_SC_PAGESIZE), stackSize); /* native heap */

if (ret != 0 || myStack == NULL) {

wc_mem_printf("posix_memalign failed\n");

return -1;

}

XMEMSET(myStack, STACK_CHECK_VAL, stackSize);

ret = pthread_attr_init(&myAttr);

if (ret != 0) {

wc_mem_printf("attr_init failed\n");

return ret;

}

ret = pthread_attr_setstack(&myAttr, myStack, stackSize);

if (ret != 0) {

wc_mem_printf("attr_setstackaddr failed\n");

return ret;

}

#ifdef HAVE_STACK_SIZE_VERBOSE

StackSizeCheck_stackSizeHWM = 0;

shim_args.myStack = myStack;

shim_args.stackSize = stackSize;

shim_args.stackSizeHWM_ptr = &StackSizeCheck_stackSizeHWM;

shim_args.fn = tf;

shim_args.args = args;

ret = pthread_create(&threadId, &myAttr,

(thread_func)debug_stack_size_verbose_shim, (void *)&shim_args);

#else

ret = pthread_create(&threadId, &myAttr, tf, args);

#endif

if (ret != 0) {

printf("ret = %d\n", ret);

perror("pthread_create failed");

exit(EXIT_FAILURE);

}

ret = pthread_join(threadId, &status);

if (ret != 0) {

wc_mem_printf("pthread_join failed\n");

return ret;

}

for (i = 0; i < stackSize; i++) {

if (myStack[i] != STACK_CHECK_VAL) {

break;

}

}

free(myStack); /* native heap */

#ifdef HAVE_STACK_SIZE_VERBOSE

printf("stack used = %lu\n", StackSizeCheck_stackSizeHWM > (stackSize - i)

? (unsigned long)StackSizeCheck_stackSizeHWM

: (unsigned long)(stackSize - i));

StackSizeCheck_myStack = NULL;

StackSizeCheck_stackOffsetPointer = NULL;

#else

{

size_t used = stackSize - i;

printf("stack used = %lu\n", (unsigned long)used);

}

#endif

return (int)((size_t)status);

}

static WC_INLINE int StackSizeCheck_launch(struct func_args* args,

thread_func tf, THREAD_TYPE *threadId, void **stack_context)

{

int ret;

unsigned char* myStack = NULL;

size_t stackSize = 1024*1024*2;

pthread_attr_t myAttr;

struct stack_size_debug_context* shim_args;

#ifdef PTHREAD_STACK_MIN

if (stackSize < (size_t)PTHREAD_STACK_MIN)

stackSize = PTHREAD_STACK_MIN;

#endif

shim_args = (struct stack_size_debug_context *)malloc(sizeof *shim_args); /* native heap */

if (shim_args == NULL) {

perror("malloc");

return -1;

}

ret = posix_memalign((void**)&myStack, sysconf(_SC_PAGESIZE), stackSize); /* native heap */

if (ret != 0 || myStack == NULL) {

wc_mem_printf("posix_memalign failed\n");

free(shim_args); /* native heap */

return -1;

}

XMEMSET(myStack, STACK_CHECK_VAL, stackSize);

ret = pthread_attr_init(&myAttr);

if (ret != 0) {

wc_mem_printf("attr_init failed\n");

free(shim_args); /* native heap */

free(myStack); /* native heap */

return ret;

}

ret = pthread_attr_setstack(&myAttr, myStack, stackSize);

if (ret != 0) {

wc_mem_printf("attr_setstackaddr failed\n");

}

shim_args->myStack = myStack;

shim_args->stackSize = stackSize;

#ifdef HAVE_STACK_SIZE_VERBOSE

shim_args->stackSizeHWM_ptr = &StackSizeCheck_stackSizeHWM;

shim_args->fn = tf;

shim_args->args = args;

ret = pthread_create((pthread_t *)threadId, &myAttr,

(thread_func)debug_stack_size_verbose_shim, (void *)shim_args);

#else

ret = pthread_create((pthread_t *)threadId, &myAttr, tf, args);

#endif

if (ret != 0) {

fprintf(stderr,"pthread_create failed: %s",strerror(ret));

exit(EXIT_FAILURE);

}

*stack_context = (void *)shim_args;

return 0;

}

static WC_INLINE int StackSizeCheck_reap(THREAD_TYPE threadId,

void *stack_context)

{

struct stack_size_debug_context *shim_args =

(struct stack_size_debug_context *)stack_context;

size_t i;

void *status;

int ret = pthread_join((pthread_t)threadId, &status);

if (ret != 0) {

wc_mem_printf("pthread_join failed\n");

return ret;

}

for (i = 0; i < shim_args->stackSize; i++) {

if (shim_args->myStack[i] != STACK_CHECK_VAL) {

break;

}

}

free(shim_args->myStack); /* native heap */

#ifdef HAVE_STACK_SIZE_VERBOSE

printf("stack used = %lu\n",

*shim_args->stackSizeHWM_ptr > (shim_args->stackSize - i)

? (unsigned long)*shim_args->stackSizeHWM_ptr

: (unsigned long)(shim_args->stackSize - i));

#else

{

size_t used = shim_args->stackSize - i;

printf("stack used = %lu\n", (unsigned long)used);

}

#endif

free(shim_args); /* native heap */

return (int)((size_t)status);

}

#else /* HAVE_PTHREAD */

static WC_INLINE int StackSizeCheck(struct func_args* args, thread_func tf)

{

void* status;

if (tf == NULL)

return -BAD_FUNC_ARG;

status = tf(args);

#ifdef HAVE_STACK_SIZE_VERBOSE

{

ssize_t used = StackSizeHWM();

if (used >= 0) {

printf("stack used = %ld\n", (long)used);

StackSizeHWMReset();

}

}

#endif

return (int)((size_t)status);

}

#define StackSizeCheck_launch(args, tf, threadId, stack_context) \

((void)(args), (void)(tf), (void)(threadId), (void)(stack_context), \

(NOT_COMPILED_IN))

#define StackSizeCheck_reap(threadId, stack_context) \

((void)(threadId), (void)(stack_context), (NOT_COMPILED_IN))

#endif /* HAVE_PTHREAD */

#endif /* HAVE_STACK_SIZE */

#ifdef STACK_TRAP

/* good settings

./configure --enable-debug --disable-shared C_EXTRA_FLAGS="-DUSER_TIME \

-DTFM_TIMING_RESISTANT -DPOSITIVE_EXP_ONLY -DSTACK_TRAP"

*/

#ifdef HAVE_STACK_SIZE

/* client only for now, setrlimit will fail if pthread_create() called */

/* STACK_SIZE does pthread_create() on client */

#error "can't use STACK_TRAP with STACK_SIZE, setrlimit will fail"

#endif /* HAVE_STACK_SIZE */

static WC_INLINE void StackTrap(void)

{

struct rlimit rl;

if (getrlimit(RLIMIT_STACK, &rl) != 0) {

wc_mem_printf("getrlimit failed\n");

}

printf("rlim_cur = %llu\n", rl.rlim_cur);

rl.rlim_cur = 1024*21; /* adjust trap size here */

if (setrlimit(RLIMIT_STACK, &rl) != 0) {

wc_mem_printf("setrlimit failed\n");

}

}

#else /* STACK_TRAP */

static WC_INLINE void StackTrap(void)

{

}

#endif /* STACK_TRAP */

/* Stubs when not used */

#ifndef STACK_SIZE_CHECKPOINT

#define STACK_SIZE_CHECKPOINT(...) (__VA_ARGS__)

#endif

#ifndef STACK_SIZE_CHECKPOINT_MSG

#define STACK_SIZE_CHECKPOINT_MSG(msg) WC_DO_NOTHING

#endif

#ifndef STACK_SIZE_CHECKPOINT_WITH_MAX_CHECK

#define STACK_SIZE_CHECKPOINT_WITH_MAX_CHECK(max, ...) (__VA_ARGS__, 0)

#endif

#ifndef STACK_SIZE_INIT

#define STACK_SIZE_INIT() WC_DO_NOTHING

#endif

#endif /* WOLFSSL_MEM_TRACK_H */