usbloadergx/source/libs/libwolfssl/wolfcrypt/mem_track.h

822 lines
22 KiB
C
Raw Normal View History

2019-11-11 18:09:59 +01:00
/* mem_track.h
*
2023-01-01 18:00:36 +01:00
* Copyright (C) 2006-2022 wolfSSL Inc.
2019-11-11 18:09:59 +01:00
*
* 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 2 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
*/
2023-01-01 18:00:36 +01:00
/* Memory and stack use tracking */
#ifndef WOLFSSL_MEM_TRACK_H
#define WOLFSSL_MEM_TRACK_H
#if defined(USE_WOLFSSL_MEMORY) && !defined(WOLFSSL_STATIC_MEMORY)
2019-11-11 18:09:59 +01:00
/* 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
*/
2023-01-01 18:00:36 +01:00
#include "wolfssl/wolfcrypt/settings.h"
#include "wolfssl/wolfcrypt/logging.h"
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
#if defined(WOLFSSL_TRACK_MEMORY) || defined(HAVE_STACK_SIZE) || \
defined(HAVE_STACK_SIZE_VERBOSE)
#include <stdio.h>
#endif
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
#if defined(WOLFSSL_TRACK_MEMORY)
#define DO_MEM_STATS
#if defined(__linux__) || defined(__MACH__)
#define DO_MEM_LIST
2019-11-11 18:09:59 +01:00
#endif
2023-01-01 18:00:36 +01:00
#endif
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
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 */
2020-12-31 20:00:44 +01:00
#ifdef WOLFSSL_TRACK_MEMORY_VERBOSE
2023-01-01 18:00:36 +01:00
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;
2019-11-11 18:09:59 +01:00
#endif
2023-01-01 18:00:36 +01:00
#endif
void* thisMemory; /* actual memory for user */
} memHint;
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
typedef struct memoryTrack {
union {
memHint hint;
byte alignit[sizeof(memHint) + ((16-1) & ~(16-1))]; /* make sure we have strong alignment */
} u;
} memoryTrack;
2019-11-11 18:09:59 +01:00
#ifdef DO_MEM_LIST
2023-01-01 18:00:36 +01:00
/* track allocations and report at end */
typedef struct memoryList {
memHint* head;
memHint* tail;
word32 count;
} memoryList;
2019-11-11 18:09:59 +01:00
#endif
#if defined(WOLFSSL_TRACK_MEMORY)
2023-01-01 18:00:36 +01:00
static memoryStats ourMemStats;
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
#ifdef DO_MEM_LIST
#include <pthread.h>
static memoryList ourMemList;
static pthread_mutex_t memLock = PTHREAD_MUTEX_INITIALIZER;
#endif
2019-11-11 18:09:59 +01:00
#endif
2023-01-01 18:00:36 +01:00
/* if defined to not using inline then declare function prototypes */
#ifdef NO_INLINE
#define WC_STATIC
#ifdef WOLFSSL_DEBUG_MEMORY
WOLFSSL_LOCAL void* TrackMalloc(size_t sz, const char* func, unsigned int line);
WOLFSSL_LOCAL void TrackFree(void* ptr, const char* func, unsigned int line);
WOLFSSL_LOCAL void* TrackRealloc(void* ptr, size_t sz, const char* func, unsigned int line);
2019-11-11 18:09:59 +01:00
#else
2023-01-01 18:00:36 +01:00
WOLFSSL_LOCAL void* TrackMalloc(size_t sz);
WOLFSSL_LOCAL void TrackFree(void* ptr);
WOLFSSL_LOCAL void* TrackRealloc(void* ptr, size_t sz);
2019-11-11 18:09:59 +01:00
#endif
2023-01-01 18:00:36 +01:00
WOLFSSL_LOCAL int InitMemoryTracker(void);
WOLFSSL_LOCAL void ShowMemoryTracker(void);
#else
#define WC_STATIC static
#endif
2019-11-11 18:09:59 +01:00
#ifdef WOLFSSL_DEBUG_MEMORY
2023-01-01 18:00:36 +01:00
WC_STATIC WC_INLINE void* TrackMalloc(size_t sz, const char* func, unsigned int line)
2019-11-11 18:09:59 +01:00
#else
2023-01-01 18:00:36 +01:00
WC_STATIC WC_INLINE void* TrackMalloc(size_t sz)
2019-11-11 18:09:59 +01:00
#endif
2023-01-01 18:00:36 +01:00
{
memoryTrack* mt;
memHint* header;
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
if (sz == 0)
return NULL;
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
#ifdef FREERTOS
mt = (memoryTrack*)pvPortMalloc(sizeof(memoryTrack) + sz);
#else
mt = (memoryTrack*)malloc(sizeof(memoryTrack) + sz);
#endif
if (mt == NULL)
return NULL;
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
header = &mt->u.hint;
header->thisSize = sz;
header->thisMemory = (byte*)mt + sizeof(memoryTrack);
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
#ifdef WOLFSSL_DEBUG_MEMORY
#ifdef WOLFSSL_DEBUG_MEMORY_PRINT
fprintf(stderr, "Alloc: %p -> %u at %s:%d\n", header->thisMemory, (word32)sz, func, line);
#else
(void)func;
(void)line;
#endif
#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) {
ourMemStats.peakBytesTripOdometer = ourMemStats.currentBytes;
2019-11-11 18:09:59 +01:00
#endif
2023-01-01 18:00:36 +01:00
if (ourMemStats.currentBytes > ourMemStats.peakBytes)
ourMemStats.peakBytes = ourMemStats.currentBytes;
#ifdef WOLFSSL_TRACK_MEMORY_VERBOSE
}
#endif
#endif
#ifdef DO_MEM_LIST
if (pthread_mutex_lock(&memLock) == 0) {
#ifdef WOLFSSL_DEBUG_MEMORY
header->func = func;
header->line = line;
2019-11-11 18:09:59 +01:00
#endif
2023-01-01 18:00:36 +01:00
/* Setup event */
header->next = NULL;
if (ourMemList.tail == NULL) {
ourMemList.head = header;
header->prev = NULL;
2020-12-31 20:00:44 +01:00
}
2023-01-01 18:00:36 +01:00
else {
ourMemList.tail->next = header;
header->prev = ourMemList.tail;
2019-11-11 18:09:59 +01:00
}
2023-01-01 18:00:36 +01:00
ourMemList.tail = header; /* add to the end either way */
ourMemList.count++;
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
pthread_mutex_unlock(&memLock);
2019-11-11 18:09:59 +01:00
}
2023-01-01 18:00:36 +01:00
#endif
return header->thisMemory;
}
2019-11-11 18:09:59 +01:00
#ifdef WOLFSSL_DEBUG_MEMORY
2023-01-01 18:00:36 +01:00
WC_STATIC WC_INLINE void TrackFree(void* ptr, const char* func, unsigned int line)
2019-11-11 18:09:59 +01:00
#else
2023-01-01 18:00:36 +01:00
WC_STATIC WC_INLINE void TrackFree(void* ptr)
2019-11-11 18:09:59 +01:00
#endif
2023-01-01 18:00:36 +01:00
{
memoryTrack* mt;
memHint* header;
size_t sz;
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
if (ptr == NULL) {
return;
}
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
mt = (memoryTrack*)((byte*)ptr - sizeof(memoryTrack));
header = &mt->u.hint;
sz = header->thisSize;
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
#ifdef DO_MEM_LIST
if (pthread_mutex_lock(&memLock) == 0)
{
#endif
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
#ifdef DO_MEM_STATS
ourMemStats.currentBytes -= header->thisSize;
ourMemStats.totalDeallocs++;
#endif
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
#ifdef DO_MEM_LIST
if (header == ourMemList.head && header == ourMemList.tail) {
ourMemList.head = NULL;
ourMemList.tail = NULL;
2019-11-11 18:09:59 +01:00
}
2023-01-01 18:00:36 +01:00
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--;
pthread_mutex_unlock(&memLock);
}
#endif
2019-11-11 18:09:59 +01:00
#ifdef WOLFSSL_DEBUG_MEMORY
#ifdef WOLFSSL_DEBUG_MEMORY_PRINT
2023-01-01 18:00:36 +01:00
fprintf(stderr, "Free: %p -> %u at %s:%d\n", ptr, (word32)sz, func, line);
2019-11-11 18:09:59 +01:00
#else
2023-01-01 18:00:36 +01:00
(void)func;
(void)line;
2019-11-11 18:09:59 +01:00
#endif
#endif
2023-01-01 18:00:36 +01:00
(void)sz;
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
#ifdef FREERTOS
vPortFree(mt);
#else
free(mt);
#endif
}
2019-11-11 18:09:59 +01:00
#ifdef WOLFSSL_DEBUG_MEMORY
2023-01-01 18:00:36 +01:00
WC_STATIC WC_INLINE void* TrackRealloc(void* ptr, size_t sz, const char* func, unsigned int line)
2019-11-11 18:09:59 +01:00
#else
2023-01-01 18:00:36 +01:00
WC_STATIC WC_INLINE void* TrackRealloc(void* ptr, size_t sz)
2019-11-11 18:09:59 +01:00
#endif
2023-01-01 18:00:36 +01:00
{
#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) {
2019-11-11 18:09:59 +01:00
#ifdef WOLFSSL_DEBUG_MEMORY
2023-01-01 18:00:36 +01:00
TrackFree(ptr, func, line);
2019-11-11 18:09:59 +01:00
#else
2023-01-01 18:00:36 +01:00
TrackFree(ptr);
2019-11-11 18:09:59 +01:00
#endif
2023-01-01 18:00:36 +01:00
}
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
return ret;
}
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
#ifdef WOLFSSL_TRACK_MEMORY
static wolfSSL_Malloc_cb mfDefault = NULL;
static wolfSSL_Free_cb ffDefault = NULL;
static wolfSSL_Realloc_cb rfDefault = NULL;
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
WC_STATIC WC_INLINE int InitMemoryTracker(void)
{
int ret;
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
ret = wolfSSL_GetAllocators(&mfDefault, &ffDefault, &rfDefault);
if (ret < 0) {
fprintf(stderr, "wolfSSL GetAllocators failed to get the defaults\n");
}
ret = wolfSSL_SetAllocators(TrackMalloc, TrackFree, TrackRealloc);
if (ret < 0) {
fprintf(stderr, "wolfSSL SetAllocators failed for track memory\n");
return ret;
}
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
#ifdef DO_MEM_LIST
if (pthread_mutex_lock(&memLock) == 0)
{
#endif
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
#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
#ifdef DO_MEM_LIST
XMEMSET(&ourMemList, 0, sizeof(ourMemList));
pthread_mutex_unlock(&memLock);
2019-11-11 18:09:59 +01:00
}
2023-01-01 18:00:36 +01:00
#endif
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
return ret;
}
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
WC_STATIC WC_INLINE void ShowMemoryTracker(void)
{
#ifdef DO_MEM_LIST
if (pthread_mutex_lock(&memLock) == 0)
2019-11-11 18:09:59 +01:00
{
2023-01-01 18:00:36 +01:00
#endif
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
#ifdef DO_MEM_STATS
fprintf(stderr, "total Allocs = %9ld\n", ourMemStats.totalAllocs);
fprintf(stderr, "total Deallocs = %9ld\n", ourMemStats.totalDeallocs);
fprintf(stderr, "total Bytes = %9ld\n", ourMemStats.totalBytes);
fprintf(stderr, "peak Bytes = %9ld\n", ourMemStats.peakBytes);
fprintf(stderr, "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) {
fprintf(stderr, "Leak: Ptr %p, Size %u"
#ifdef WOLFSSL_DEBUG_MEMORY
", Func %s, Line %d"
#endif
"\n",
(byte*)header + sizeof(memHint), (unsigned int)header->thisSize
#ifdef WOLFSSL_DEBUG_MEMORY
, header->func, header->line
#endif
);
2019-11-11 18:09:59 +01:00
}
2023-01-01 18:00:36 +01:00
}
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
pthread_mutex_unlock(&memLock);
}
#endif
}
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
WC_STATIC WC_INLINE int CleanupMemoryTracker(void)
{
/* restore default allocators */
return wolfSSL_SetAllocators(mfDefault, ffDefault, rfDefault);
}
#endif /* WOLFSSL_TRACK_MEMORY */
#endif /* USE_WOLFSSL_MEMORY && !WOLFSSL_STATIC_MEMORY */
#ifdef HAVE_STACK_SIZE
#include <stdio.h>
#include <pthread.h>
#include <errno.h>
#include <sched.h>
#include <unistd.h>
#include <libs/libwolfssl/wolfcrypt/types.h>
#include <libs/libwolfssl/wolfcrypt/logging.h>
#include <libs/libwolfssl/wolfcrypt/error-crypt.h>
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;
2020-12-31 20:00:44 +01:00
#endif
2023-01-01 18:00:36 +01:00
};
2020-12-31 20:00:44 +01:00
2023-01-01 18:00:36 +01:00
struct func_args; /* forward declaration */
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
#ifdef HAVE_STACK_SIZE_VERBOSE
/* 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;
2019-11-11 18:09:59 +01:00
}
2023-01-01 18:00:36 +01:00
}
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(); \
fprintf(stderr, "%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))) { \
fprintf(stderr, \
" 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
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
#endif /* HAVE_STACK_SIZE_VERBOSE */
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 < PTHREAD_STACK_MIN)
stackSize = PTHREAD_STACK_MIN;
#endif
ret = posix_memalign((void**)&myStack, sysconf(_SC_PAGESIZE), stackSize);
if (ret != 0 || myStack == NULL) {
fprintf(stderr, "posix_memalign failed\n");
return -1;
}
XMEMSET(myStack, STACK_CHECK_VAL, stackSize);
ret = pthread_attr_init(&myAttr);
if (ret != 0) {
fprintf(stderr, "attr_init failed\n");
2019-11-11 18:09:59 +01:00
return ret;
}
2023-01-01 18:00:36 +01:00
ret = pthread_attr_setstack(&myAttr, myStack, stackSize);
if (ret != 0) {
fprintf(stderr, "attr_setstackaddr failed\n");
return ret;
}
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
#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);
}
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
ret = pthread_join(threadId, &status);
if (ret != 0) {
fprintf(stderr, "pthread_join failed\n");
return ret;
}
for (i = 0; i < stackSize; i++) {
if (myStack[i] != STACK_CHECK_VAL) {
break;
2019-11-11 18:09:59 +01:00
}
2023-01-01 18:00:36 +01:00
}
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
free(myStack);
#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, pthread_t *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 < PTHREAD_STACK_MIN)
stackSize = PTHREAD_STACK_MIN;
#endif
shim_args = (struct stack_size_debug_context *)malloc(sizeof *shim_args);
if (shim_args == NULL) {
perror("malloc");
return -1;
}
ret = posix_memalign((void**)&myStack, sysconf(_SC_PAGESIZE), stackSize);
if (ret != 0 || myStack == NULL) {
fprintf(stderr, "posix_memalign failed\n");
free(shim_args);
return -1;
}
XMEMSET(myStack, STACK_CHECK_VAL, stackSize);
ret = pthread_attr_init(&myAttr);
if (ret != 0) {
fprintf(stderr, "attr_init failed\n");
free(shim_args);
free(myStack);
return ret;
}
ret = pthread_attr_setstack(&myAttr, myStack, stackSize);
if (ret != 0) {
fprintf(stderr, "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(threadId, &myAttr,
(thread_func)debug_stack_size_verbose_shim, (void *)shim_args);
#else
ret = pthread_create(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(pthread_t 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(threadId, &status);
if (ret != 0) {
fprintf(stderr, "pthread_join failed\n");
return ret;
}
for (i = 0; i < shim_args->stackSize; i++) {
if (shim_args->myStack[i] != STACK_CHECK_VAL) {
break;
2019-11-11 18:09:59 +01:00
}
}
2023-01-01 18:00:36 +01:00
free(shim_args->myStack);
#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
2019-11-11 18:09:59 +01:00
{
2023-01-01 18:00:36 +01:00
size_t used = shim_args->stackSize - i;
printf("stack used = %lu\n", (unsigned long)used);
2019-11-11 18:09:59 +01:00
}
#endif
2023-01-01 18:00:36 +01:00
free(shim_args);
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
return (int)((size_t)status);
}
2019-11-11 18:09:59 +01:00
2023-01-01 18:00:36 +01:00
#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) {
fprintf(stderr, "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) {
fprintf(stderr, "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)
#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()
#endif
#endif /* WOLFSSL_MEM_TRACK_H */