void CheckArgumentsOverflow()
{
void *p;
const size_t params[] = {SIZE_MAX, SIZE_MAX-16};
for (unsigned i=0; i<Harness::array_length(params); i++) {
p = Tmalloc(params[i]);
ASSERT(!p, NULL);
ASSERT_ERRNO(errno==ENOMEM, NULL);
p = Trealloc(NULL, params[i]);
ASSERT(!p, NULL);
ASSERT_ERRNO(errno==ENOMEM, NULL);
p = Tcalloc(1, params[i]);
ASSERT(!p, NULL);
ASSERT_ERRNO(errno==ENOMEM, NULL);
p = Tcalloc(params[i], 1);
ASSERT(!p, NULL);
ASSERT_ERRNO(errno==ENOMEM, NULL);
}
const size_t max_alignment = size_t(1) << (sizeof(size_t)*CHAR_BIT - 1);
if (Rposix_memalign) {
int ret = Rposix_memalign(&p, max_alignment, ~max_alignment);
ASSERT(ret == ENOMEM, NULL);
for (unsigned i=0; i<Harness::array_length(params); i++) {
ret = Rposix_memalign(&p, max_alignment, params[i]);
ASSERT(ret == ENOMEM, NULL);
ret = Rposix_memalign(&p, sizeof(void*), params[i]);
ASSERT(ret == ENOMEM, NULL);
}
}
if (Raligned_malloc) {
p = Raligned_malloc(~max_alignment, max_alignment);
ASSERT(!p, NULL);
for (unsigned i=0; i<Harness::array_length(params); i++) {
p = Raligned_malloc(params[i], max_alignment);
ASSERT(!p, NULL);
ASSERT_ERRNO(errno==ENOMEM, NULL);
p = Raligned_malloc(params[i], sizeof(void*));
ASSERT(!p, NULL);
ASSERT_ERRNO(errno==ENOMEM, NULL);
}
}
p = Tcalloc(SIZE_MAX/2-16, SIZE_MAX/2-16);
ASSERT(!p, NULL);
ASSERT_ERRNO(errno==ENOMEM, NULL);
p = Tcalloc(SIZE_MAX/2, SIZE_MAX/2);
ASSERT(!p, NULL);
ASSERT_ERRNO(errno==ENOMEM, NULL);
}
void CMemTest::TestAlignedParameters()
{
void *memptr;
int ret;
if (Rposix_memalign) {
// alignment isn't power of 2
for (int bad_align=3; bad_align<16; bad_align++)
if (bad_align&(bad_align-1)) {
ret = Tposix_memalign(NULL, bad_align, 100);
ASSERT(EINVAL==ret, NULL);
}
memptr = &ret;
ret = Tposix_memalign(&memptr, 5*sizeof(void*), 100);
ASSERT(memptr == &ret,
"memptr should not be changed after unsuccessful call");
ASSERT(EINVAL==ret, NULL);
// alignment is power of 2, but not a multiple of sizeof(void *),
// we expect that sizeof(void*) > 2
ret = Tposix_memalign(NULL, 2, 100);
ASSERT(EINVAL==ret, NULL);
}
if (Raligned_malloc) {
// alignment isn't power of 2
for (int bad_align=3; bad_align<16; bad_align++)
if (bad_align&(bad_align-1)) {
memptr = Taligned_malloc(100, bad_align);
ASSERT(NULL==memptr, NULL);
ASSERT_ERRNO(EINVAL==errno, NULL);
}
// size is zero
memptr = Taligned_malloc(0, 16);
ASSERT(NULL==memptr, "size is zero, so must return NULL");
ASSERT_ERRNO(EINVAL==errno, NULL);
}
if (Taligned_free) {
// NULL pointer is OK to free
errno = 0;
Taligned_free(NULL);
/* As there is no return value for free, strictly speaking we can't
check errno here. But checked implementations obey the assertion.
*/
ASSERT_ERRNO(0==errno, NULL);
}
if (Raligned_realloc) {
for (int i=1; i<20; i++) {
// checks that calls work correctly in presence of non-zero errno
errno = i;
void *ptr = Taligned_malloc(i*10, 128);
ASSERT(NULL!=ptr, NULL);
ASSERT_ERRNO(0!=errno, NULL);
// if size is zero and pointer is not NULL, works like free
memptr = Taligned_realloc(ptr, 0, 64);
ASSERT(NULL==memptr, NULL);
ASSERT_ERRNO(0!=errno, NULL);
}
// alignment isn't power of 2
for (int bad_align=3; bad_align<16; bad_align++)
if (bad_align&(bad_align-1)) {
void *ptr = &bad_align;
memptr = Taligned_realloc(&ptr, 100, bad_align);
ASSERT(NULL==memptr, NULL);
ASSERT(&bad_align==ptr, NULL);
ASSERT_ERRNO(EINVAL==errno, NULL);
}
}
}
void CMemTest::NULLReturn(UINT MinSize, UINT MaxSize, int total_threads)
{
const int MB_PER_THREAD = TOTAL_MB_ALLOC / total_threads;
// find size to guarantee getting NULL for 1024 B allocations
const int MAXNUM_1024 = (MB_PER_THREAD + (MB_PER_THREAD>>2)) * 1024;
std::vector<MemStruct> PointerList;
void *tmp;
CountErrors=0;
int CountNULL, num_1024;
if (FullLog) REPORT("\nNULL return & check errno:\n");
UINT Size;
Limit limit_total(TOTAL_MB_ALLOC), no_limit(0);
void **buf_1024 = (void**)Tmalloc(MAXNUM_1024*sizeof(void*));
ASSERT(buf_1024, NULL);
/* We must have space for pointers when memory limit is hit.
Reserve enough for the worst case, taking into account race for
limited space between threads.
*/
PointerList.reserve(TOTAL_MB_ALLOC*MByte/MinSize);
/* There is a bug in the specific version of GLIBC (2.5-12) shipped
with RHEL5 that leads to erroneous working of the test
on Intel64 and IPF systems when setrlimit-related part is enabled.
Switching to GLIBC 2.5-18 from RHEL5.1 resolved the issue.
*/
if (perProcessLimits)
limitBarrier->wait(limit_total);
else
limitMem(MB_PER_THREAD);
/* regression test against the bug in allocator when it dereference NULL
while lack of memory
*/
for (num_1024=0; num_1024<MAXNUM_1024; num_1024++) {
buf_1024[num_1024] = Tcalloc(1024, 1);
if (! buf_1024[num_1024]) {
ASSERT_ERRNO(errno == ENOMEM, NULL);
break;
}
}
for (int i=0; i<num_1024; i++)
Tfree(buf_1024[i]);
Tfree(buf_1024);
do {
Size=rand()%(MaxSize-MinSize)+MinSize;
tmp=Tmalloc(Size);
if (tmp != NULL)
{
myMemset(tmp, 0, Size);
PointerList.push_back(MemStruct(tmp, Size));
}
} while(tmp != NULL);
ASSERT_ERRNO(errno == ENOMEM, NULL);
if (FullLog) REPORT("\n");
// preparation complete, now running tests
// malloc
if (FullLog) REPORT("malloc....");
CountNULL = 0;
while (CountNULL==0)
for (int j=0; j<COUNT_TESTS; j++)
{
Size=rand()%(MaxSize-MinSize)+MinSize;
errno = ENOMEM+j+1;
tmp=Tmalloc(Size);
if (tmp == NULL)
{
CountNULL++;
if ( CHECK_ERRNO(errno != ENOMEM) ) {
CountErrors++;
if (ShouldReportError()) REPORT("NULL returned, error: errno (%d) != ENOMEM\n", errno);
}
}
else
{
// Technically, if malloc returns a non-NULL pointer, it is allowed to set errno anyway.
// However, on most systems it does not set errno.
bool known_issue = false;
#if __linux__
if( CHECK_ERRNO(errno==ENOMEM) ) known_issue = true;
#endif /* __linux__ */
if ( CHECK_ERRNO(errno != ENOMEM+j+1) && !known_issue) {
CountErrors++;
if (ShouldReportError()) REPORT("error: errno changed to %d though valid pointer was returned\n", errno);
}
myMemset(tmp, 0, Size);
PointerList.push_back(MemStruct(tmp, Size));
}
}
if (FullLog) REPORT("end malloc\n");
if (CountErrors) REPORT("%s\n",strError);
else if (FullLog) REPORT("%s\n",strOk);
error_occurred |= ( CountErrors>0 ) ;
CountErrors=0;
//calloc
if (FullLog) REPORT("calloc....");
CountNULL = 0;
while (CountNULL==0)
for (int j=0; j<COUNT_TESTS; j++)
{
Size=rand()%(MaxSize-MinSize)+MinSize;
errno = ENOMEM+j+1;
tmp=Tcalloc(COUNT_ELEM_CALLOC,Size);
if (tmp == NULL)
{
CountNULL++;
if ( CHECK_ERRNO(errno != ENOMEM) ){
CountErrors++;
if (ShouldReportError()) REPORT("NULL returned, error: errno(%d) != ENOMEM\n", errno);
}
}
else
{
// Technically, if calloc returns a non-NULL pointer, it is allowed to set errno anyway.
// However, on most systems it does not set errno.
bool known_issue = false;
#if __linux__
if( CHECK_ERRNO(errno==ENOMEM) ) known_issue = true;
#endif /* __linux__ */
if ( CHECK_ERRNO(errno != ENOMEM+j+1) && !known_issue ) {
CountErrors++;
if (ShouldReportError()) REPORT("error: errno changed to %d though valid pointer was returned\n", errno);
}
PointerList.push_back(MemStruct(tmp, Size));
}
}
if (FullLog) REPORT("end calloc\n");
if (CountErrors) REPORT("%s\n",strError);
else if (FullLog) REPORT("%s\n",strOk);
error_occurred |= ( CountErrors>0 ) ;
CountErrors=0;
if (FullLog) REPORT("realloc....");
CountNULL = 0;
if (PointerList.size() > 0)
while (CountNULL==0)
for (size_t i=0; i<(size_t)COUNT_TESTS && i<PointerList.size(); i++)
{
errno = 0;
tmp=Trealloc(PointerList[i].Pointer,PointerList[i].Size*2);
if (PointerList[i].Pointer == tmp) // the same place
{
bool known_issue = false;
#if __linux__
if( errno==ENOMEM ) known_issue = true;
#endif /* __linux__ */
if (errno != 0 && !known_issue) {
CountErrors++;
if (ShouldReportError()) REPORT("valid pointer returned, error: errno not kept\n");
}
PointerList[i].Size *= 2;
}
else if (tmp != PointerList[i].Pointer && tmp != NULL) // another place
{
bool known_issue = false;
#if __linux__
if( errno==ENOMEM ) known_issue = true;
#endif /* __linux__ */
if (errno != 0 && !known_issue) {
CountErrors++;
if (ShouldReportError()) REPORT("valid pointer returned, error: errno not kept\n");
}
// newly allocated area have to be zeroed
myMemset((char*)tmp + PointerList[i].Size, 0, PointerList[i].Size);
PointerList[i].Pointer = tmp;
PointerList[i].Size *= 2;
}
else if (tmp == NULL)
{
CountNULL++;
if ( CHECK_ERRNO(errno != ENOMEM) )
{
CountErrors++;
if (ShouldReportError()) REPORT("NULL returned, error: errno(%d) != ENOMEM\n", errno);
}
// check data integrity
if (NonZero(PointerList[i].Pointer, PointerList[i].Size)) {
CountErrors++;
if (ShouldReportError()) REPORT("NULL returned, error: data changed\n");
}
}
}
if (FullLog) REPORT("realloc end\n");
if (CountErrors) REPORT("%s\n",strError);
else if (FullLog) REPORT("%s\n",strOk);
error_occurred |= ( CountErrors>0 ) ;
for (UINT i=0; i<PointerList.size(); i++)
{
Tfree(PointerList[i].Pointer);
}
if (perProcessLimits)
limitBarrier->wait(no_limit);
else
limitMem(0);
}
