[C] corrupted double-linked list

[honda4life]

Hallo iedereen,

Ik snap niet waarom ik onderstaande error krijg bij het uitvoeren van het programma:
*** glibc detected *** ./SMAspot: corrupted double-linked list: 0x00378998 ***
Afgebroken

Ik heb 2 gelijkaardige functies, de ene voor het ophalen van data, en de andere voor het verzenden van data en zijn in wezen identiek buiten een andere struct.
Het verzenden van data lukt niet (altijd?).
Wanneer ik een realloc doe per item, geraak ik 72 items ver met een segmentatiefout.
Maak ik men stuct groter, gebeurt de fout sneller, ik vermoed dat het fout gaat indien de pointer van adres verandert.
Heeft iemand een idee waarom?

Enkele belangrijke delen uit de code:
"globale" variabelen:

C:

PVOutPut *statuses = NULL;
unsigned int num_statuses = 0;
unsigned int alloc_statuses = 0;

Onderstaande functie wordt in een lus aangesproken:

C:

int AddToArray_put(PVOutPut item, unsigned int alloc_new)
{
    if(VERBOSE_HIGHEST) puts("AddToArray_put()");
    printf("item.datetime: %s\n", strftime_t("%d/%m/%Y %H:%M:%S", item.datetime));
    printf("item.engen: %llu\n", item.engen);
    printf("item.powgen: %i\n", item.powgen);
    printf("item.voltage: %lu\n", item.voltage);
    printf("alloc_new: %i\n", alloc_new);

    PVOutPut *tmpptr = NULL;
    printf("*tmpptr: %p\n", tmpptr);

    printf("num_statuses: %i\n", num_statuses);
    printf("alloc_statuses: %i\n", alloc_statuses);

    //If array full and no new allocation requested, set request to 1
    if((alloc_new == 0) and (num_statuses == alloc_statuses))
        alloc_new = 1;

    printf("alloc_new: %i\n", alloc_new);

    alloc_statuses = alloc_statuses + alloc_new;

    printf("alloc_statuses: %i\n", alloc_statuses);
    printf("statuses: %p\n", statuses);
    printf("sizeof(PVOutPut): %i\n", sizeof(PVOutPut));

    //statuses = (PVOutPut*)realloc(statuses, alloc_statuses * sizeof(PVOutPut));
    tmpptr = (PVOutPut*)realloc(statuses, alloc_statuses * sizeof(PVOutPut));

    printf("*tmpptr: %p\n", tmpptr);

    if(tmpptr != NULL){
        statuses = tmpptr;
        printf("statuses: %p\n", tmpptr);
        statuses[num_statuses] = item;
        num_statuses++;
        printf("num_statuses: %i\n", num_s corrupted double-linkedtatuses);
        //alloc_new = 0;
    }
    else{
        if(VERBOSE_LOW) puts("realloc() failed!");
        return -1;
    }
    //statuses[num_statuses] = item;
    //num_statuses++;

    //if(!statuses){
        //if(VERBOSE_LOW) puts("realloc() failed!");
        //return -1;
    //}
    //statuses[num_statuses] = item;
    //num_statuses++;
    //alloc_new = 0;

    if(DEBUG_VERYHIGH){
        printf("Number of statuses: %i using %i/%i bytes\n", num_statuses, num_statuses * sizeof(PVOutPut), alloc_statuses * sizeof(PVOutPut));
        //printf("statuses[%i].time: %s\t", num_statuses - 1, strftime_t(cfg->DateTimeFormat, statuses[num_records - 1].datetime));
        printf("statuses[%i].time: %s\t", num_statuses - 1, strftime_t("%d/%m/%Y %H:%M:%S", statuses[num_statuses - 1].datetime));
        printf("statuses[%i].engen: %llu\t",  num_statuses - 1, statuses[num_statuses - 1].engen);
        printf("statuses[%i].powgen: %i\n",   num_statuses - 1, statuses[num_statuses - 1].powgen);
        //printf("statuses[%i].voltage: %llu\t", num_statuses - 1, statuses[num_records - 1].voltage);
    }

    return num_statuses;
}

Ik krijg volgende output van m'n printf's:

code:

AddToArray_put()
item.datetime: 17/03/2013 07:30:00
item.engen: 7261403
item.powgen: 0
item.voltage: 0
alloc_new: 37
*tmpptr: (nil)
num_statuses: 0
alloc_statuses: 0
alloc_new: 37
alloc_statuses: 37
statuses: (nil)
sizeof(PVOutPut): 20
*** glibc detected *** ./SMAspot: corrupted double-linked list: 0x00378998 ***
Afgebroken

Bedankt wie kan helpen, want ik ben ver ten einde raad.

[leuk_he]

Ik zie zo snel de fout niet, maar het probleem is dus dat je heap corrupt is voordat je realloc aanroept. Waar dit wel gebeurd is me niet duidelijk.

Het eerste wat in me opkomt: kun je met een memory check programma zoals valgrind vinden WAAR de corruptie optreed.

[ Voor 3% gewijzigd door leuk_he op 17-03-2013 11:55 ]

[honda4life]

Aan de output te zien doet de fout zich voor na regel 26, dus de realloc zelve.

valgrind heb ik inderdaad al eens geprobeerd, echter draait het programma niet identiek (connectie geeft ogenblikkelijk time-out en er is dus geen data om te verwerken)

Ik heb inmiddels de statusses als argument (pointer) meegegeven, ook dit geeft geen verschil.

Op een ander systeem dit uitvoeren geeft een fout na een ander aantal items... ik vermoed dus sterk dat het fout gaat wanneer er geen aansluitende blok geheugen beschikbaar is, en een nieuwe locatie voorzien wordt met wel voldoende aansluitend geheugen.

[ Voor 26% gewijzigd door honda4life op 17-03-2013 12:09 ]

[Soultaker]

Wat leuk_he bedoelt is dat het probleem dat zich manifesteert op regel 26 in de gepostte code veroorzaakt kan zijn door een fout ergens anders in het programma, die de interne datastructuren van de allocator verprutst heeft. Dan moet je denken aan operaties als meer dan één keer free() aanroepen op een gealloceerde pointer, of schrijven buiten de grenzen van een dynamisch gealloceerde array.

Omdat er in die functie niet veel interessants gebeurt (als ik de logfile goed lees doe je op regel 26 realloc(NULL, 740), waar op zichzelf niets mis mee is) zit de fout dus waarschijnlijk ergens anders.

[honda4life]

Blijkbaar werkt het nu, ik ben nog een beetje aan het prutsen geweest, maar kan echt niet bedenken dat ik iets zinvols gedaan heb.
Dit probleem komt vast wel terug.

Met realloc(NULL, 740) is inderdaad niks mis, dit is in feite een malloc als je de documentatie leest.

Ik zou zeggen hou het topic nog even geopend, en afwachten hé...

[leuk_he]

Soultaker schreef op zondag 17 maart 2013 @ 15:54:
Wat leuk_he bedoelt is dat het probleem dat zich manifesteert op regel 26 in de gepostte code veroorzaakt kan zijn door een fout ergens anders in het programma,

Dat weet ik wel zeker. Als je ergens voorbij het gealloceerde geheugen krast, dan overrschrijf je de strukturen die nodig zijn om de heap te administreren. Daar zit ook die double linked list die corrupt is. Die corruptie gebeurd ergens anders, niet op het moment van de realloc, dat is enkel het moment dat er blijkbaar een check op zit. Wellicht kun je met een visuele debugger de heap doorbladeren, en zie je dat er ergens over (of ONDER) een stuk geheugen wordt geschreven.

[Soultaker]

Ik ben het met je eens hoor Ik lichtte het alleen even toe voor honda4life, die niet leek te begrijpen dat een probleem ergens anders veroorzaakt kan zijn dan waar je er mee geconfronteerd wordt.

Dat zijn wel irritante bugs om te debuggen trouwens, omdat de fout zo'n beetje overal kan zitten. In C-programma's gebruik ik meestal mudflap (GCC: compileren met -fmudflap -lmudflap) om die fouten te vinden. (Valgrind is ook een goede tool.)