mirror of
https://github.com/Unidata/netcdf-c.git
synced 2025-01-06 15:34:44 +08:00
751300ec59
This is a follow up to PR https://github.com/Unidata/netcdf-c/pull/1173 Sorry that it is so big, but leak suppression can be complex. This PR fixes all remaining memory leaks -- as determined by -fsanitize=address, and with the exceptions noted below. Unfortunately. there remains a significant leak that I cannot solve. It involves vlens, and it is unclear if the leak is occurring in the netcdf-c library or the HDF5 library. I have added a check_PROGRAM to the ncdump directory to show the problem. The program is called tst_vlen_demo.c To exercise it, build the netcdf library with -fsanitize=address enabled. Then go into ncdump and do a "make clean check". This should build tst_vlen_demo without actually executing it. Then do the command "./tst_vlen_demo" to see the output of the memory checker. Note the the lost malloc is deep in the HDF5 library (in H5Tvlen.c). I am temporarily working around this error in the following way. 1. I modified several test scripts to not execute known vlen tests that fail as described above. 2. Added an environment variable called NC_VLEN_NOTEST. If set, then those specific tests are suppressed. This should mean that the --disable-utilities option to ./configure should not need to be set to get a memory leak clean build. This should allow for detection of any new leaks. Note: I used an environment variable rather than a ./configure option to control the vlen tests. This is because it is temporary (I hope) and because it is a bit tricky for shell scripts to access ./configure options. Finally, as before, this only been tested with netcdf-4 and hdf5 support.
116 lines
1.9 KiB
C
116 lines
1.9 KiB
C
/*
|
|
Copyright (c) 1998-2017 University Corporation for Atmospheric Research/Unidata
|
|
See LICENSE.txt for license information.
|
|
*/
|
|
|
|
#include "includes.h"
|
|
|
|
#define TRACE
|
|
|
|
extern char* ncclassname(nc_class);
|
|
|
|
#ifdef TRACE
|
|
#define T(fcn,mem) {if(trace) {fprintf(stderr,"X: %s: %p\n", fcn,mem);}}
|
|
#else
|
|
#define T(fcn,mem)
|
|
#endif
|
|
|
|
int debug = 0;
|
|
static int trace = 0;
|
|
|
|
int
|
|
settrace(int tf)
|
|
{
|
|
trace = tf;
|
|
return 1;
|
|
}
|
|
|
|
|
|
void fdebug(const char *fmt, ...)
|
|
{
|
|
va_list argv;
|
|
if(debug == 0) return;
|
|
va_start(argv,fmt);
|
|
(void)vfprintf(stderr,fmt,argv) ;
|
|
}
|
|
|
|
/**************************************************/
|
|
|
|
/* Support debugging of memory*/
|
|
|
|
void
|
|
chkfree(void* memory)
|
|
{
|
|
if(memory == NULL) {
|
|
panic("free: null memory");
|
|
}
|
|
T("free",memory);
|
|
free(memory);
|
|
}
|
|
|
|
void*
|
|
chkmalloc(size_t size)
|
|
{
|
|
void* memory = malloc(size);
|
|
if(memory == NULL) {
|
|
panic("malloc:out of memory");
|
|
}
|
|
T("malloc",memory);
|
|
return memory;
|
|
}
|
|
|
|
void*
|
|
chkcalloc(size_t size)
|
|
{
|
|
void* memory = calloc(size,1); /* use calloc to zero memory*/
|
|
if(memory == NULL) {
|
|
panic("calloc:out of memory");
|
|
}
|
|
T("calloc",memory);
|
|
return memory;
|
|
}
|
|
|
|
void*
|
|
chkrealloc(void* ptr, size_t size)
|
|
{
|
|
void* memory = realloc(ptr,size);
|
|
if(memory == NULL) {
|
|
panic("realloc:out of memory");
|
|
}
|
|
if(ptr != memory) {T("free",memory); T("realloc",memory);}
|
|
return memory;
|
|
}
|
|
|
|
char*
|
|
chkstrdup(const char* s)
|
|
{
|
|
char* dup;
|
|
if(s == NULL) {
|
|
panic("strdup: null argument");
|
|
}
|
|
dup = strdup(s);
|
|
if(dup == NULL) {
|
|
panic("strdup: out of memory");
|
|
}
|
|
T("strdup",dup);
|
|
return dup;
|
|
}
|
|
|
|
int
|
|
panic(const char* fmt, ...)
|
|
{
|
|
va_list args;
|
|
if(fmt != NULL) {
|
|
va_start(args, fmt);
|
|
vfprintf(stderr, fmt, args);
|
|
fprintf(stderr, "\n" );
|
|
va_end( args );
|
|
} else {
|
|
fprintf(stderr, "panic" );
|
|
}
|
|
fprintf(stderr, "\n" );
|
|
fflush(stderr);
|
|
abort();
|
|
return 0;
|
|
}
|