Wiederholte Allokation von Conditional endet mit Segmentation Fault

Hallo,
ich habe eine struct in C auf Linux, die u.a. einen pthread_mutex_t* und einen pthread_cond_t* hat. Ferner habe ich dafuer eine Funktion die quasi als Constructor, Platz fuer eine Instanz der struct, sowie der einzelnen allokierbaren Elemente anlegt, als auch einen Destructor, eine Funktion zum Kopieren und eine zum Initialisieren. Das funktioniert soweit fehlerfrei schon einige Zeit in meiner Software, sodass ich davon ausgehen kann, dass die Funktionen (einigermassen) korrekt implementiert sind.

typedef struct some_dummy 
{ 
  int size; 
  list_p list; 
  pthread_mutex_t* lock; 
  pthread_cond_t* cond; 
} dummy_type;

Nun habe ich eine Situation, in der ich ein SIGSEGV bekomme bei einem Aufruf des Konstructors, der ja eine NEUE Instanz allokiert zurueckgeben soll. Das ganze tritt auf bei der Allokation der Konditional Variablen ist absolut reproduzierbar und tritt ausschliesslich auf, wenn ich den selben Vorgang vorher schon einmal gemacht habe (andere Variable, aber selber Typ, wird danach gleich behandelt).

dummy_type
dummy_Ctr()
{
    calloc( dummy, sizeof(struct dummy_type) );
    dummy->size = 0;
    dummy->list = list_Init();
    if(NULL == (dummy->lock = calloc( dummy->lock, sizeof( pthread_mutex_t ) ) ) ) exit(1);
    if( NULL == (dummy->cond = calloc( dummy->cond, sizeof( pthread_cond_t ) ) ) ) exit(1); // SIGSEGV, warum?
    MTX_INIT(dummy->lock);
    CND_INIT(dummy->cond);
    return dummy;
}

Woran kann das liegen dass eine Allokation einen Segmentation Fault gibt? Die Zeiter sind ausreichend gross. Was ich hier suche, ist nicht eine "Aufloesung", sondern eher Tipps, warum eine Allokation einer eig. neuen Conditional ueberhaupt in einem Segmentation Fault enden kann. Warum, das ganze nur beim zweiten mal auftreten kann. Und/Oder, wie kann ich beim Debuggen per gdb vorgehen? Evtl. wo kann ich einen Watchpoint setzen, bzw. wie kann man so einen Fehler am besten aufspueren?

LordJaxom

SigSegSepp schrieb:

calloc( dummy, sizeof(struct dummy_type) );

Was ist das?! Bitte mal das Handbuch zu calloc durchlesen

Nein. Hilft NICHT!

ja, ok, das war eher phantasie(voller) Code, in "real" nehme ich keine direkten calloc bzw alloc, bzw realloc her, sondern library macros. Sowas wie folgendes etwa:

#define MY_ALLOC( ptr, size )                          \
  if(NULL == (ptr = calloc( sizeof(*(ptr)), size))){    \
    MY_ERR_MSG( "allocation failure" );                     \
    kill( getpid(), SIGINT );                       \
  }

...plus Signalhandler, der SIGINT faengt und das Ding entsprechend aufraeumt.. sry, daran liegts nicht. Der Code laeuft auch einwandfrei, das Problem vermute ich eher in irgendwo zu wenig allokiert, dann aber zu viel reingeschrieben und vllt damit was "wichtiges" ueberschrieben? Evtl. von einem parallel laufendem Thread, somit wird der halb allokierte pthread_cond_t* vllt irgendwie korrumpiert, bzw der Pointer der damit initialisert werden soll... kann das sein? kA, wie debugt man am besten Segmentation Faults bei Allokationen?

Hallo, ich habe die Antwort mittlerweile gefunden: mtrace
http://munir.wordpress.com/2006/08/05/finding-memory-leaks-using-mtrace/