From Bugzilla Helper:
User-Agent: Mozilla/4.75 [ja] (WinNT; U)

Description of problem:
Simple program using pthread lib occurs Segmentation fault.
The program is multi thread and multi process.


Version-Release number of selected component (if applicable):


How reproducible:
Always

Steps to Reproduce:
1.compile the test program.
2.run it
3.
    

Actual Results:  Segmentation fault on malloc() or free().

Expected Results:  work forever.

Additional info:

The test program is added last.
The components are:
    kernel: 2.4.9 or 2.4.18
    glibc : 2.2.4-19.3
    glibc-devel :2.2.4-19.3

This program works fine on i386 platform even if it has 4 processors.
If you comment out the DummyFork() function from this program,
It may work fine.
We have many huge products by using both multithread/multiprocess,
but can't port them onto IA64 platform by this issue.
Is this issue of this test program specific?
Do you have any countermeasures fot this issue?

#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <string.h>

#define THREADS 10
#define _DEBUG_BLOCKS	0x100
#define LOCAL_RAND_MAX  0x10000

void DummyFork( void );		// fork(),waitpid(),sleep()
void ChunkTest( void );		// malloc(),free(),memset()/new,delete
void *TestThread(void *pVoid);	// thread function

int main()
{
	int iTest = 0;

	// Make test threads
	for(iTest = 0; iTest < THREADS; iTest++)
	{
		int iIsCreate = 0;
		pthread_t tTestThread;
		iIsCreate = pthread_create(&tTestThread, 0, TestThread, (void *)iTest);
		if(iIsCreate != 0)
			printf("%dth Thread create error.\n", iTest);
	}

	// Main loop, just do malloc/free and fork.
	TestThread( (void*)-1 );
	return 0;
}


void *TestThread(void *pVoid)
{
	while(1)
	{
		printf( "thread No= %d\n", (int)pVoid );
		ChunkTest();  // do malloc/memset/free temporarily
		DummyFork();  // do fork/wait temporarily
	}
	return NULL;  // Dummy
}


// This is just dummy func. 
// Make child process, sleep 1 sec, and return when child process is done.
void DummyFork()
{
	pid_t tPid = 0;
	tPid = fork();
	if(tPid == 0)
	{
		// Child
		sleep(1);
		exit(0);
	}
	if(tPid > 0)
		waitpid(tPid, NULL, 0);
}


// This func do "malloc()" and "free()" randomly.
void ChunkTest( void )
{
	int iIndex = 0;
	void *pTest[_DEBUG_BLOCKS] = { [0 ... _DEBUG_BLOCKS-1] = NULL };

	srand((unsigned int)time(NULL));	// Initialize
	for(iIndex = 0; iIndex < _DEBUG_BLOCKS; iIndex++)
	{
		unsigned long uSize = 0;
		uSize = (unsigned long)(1.0*LOCAL_RAND_MAX*(double)rand()/RAND_MAX+1.0);
		pTest[iIndex] = (void *)malloc(uSize);
		if(pTest[iIndex] != NULL)
			memset(pTest[iIndex], 0x00, uSize);
	}

	for(iIndex = 0; iIndex < _DEBUG_BLOCKS; iIndex++)
		if(pTest[iIndex] != NULL) {
			free(pTest[iIndex]);
		}
}