c domande malloc (corruzione mem)

Question

Quando si utilizza malloc, se produce un dump principale con l'errore:

malloc(): memory corruption: ....... ***

Questo significa che malloc ha tentato di allocare memoria che non era libera di allocare? SE allora quali sono le cause di ciò?

Answer 1

Dipende completamente dall'implementazione di malloc, ma di solito ciò significa che ad un certo punto prima di quel malloc qualcosa scriveva più dati in un buffer di malloced rispetto alle sue dimensioni.

Molte implementazioni di malloc memorizzano alcuni dei loro dati in linea con la loro memoria, in altre parole:

+--------------------------------+
|14 bytes -> Padding             | 
+--------------------------------+
|2 bytes -> Internal malloc info |
+--------------------------------+
|6 bytes -> Your data            |
+--------------------------------+
|8 bytes -> Padding              |
+--------------------------------+
|2 bytes -> Internal malloc info |
+--------------------------------+

Quindi, se un tuo codice o una libreria scrivessero 16 byte in quel buffer di 6 byte, sovrascriverebbero il riempimento e i 2 byte delle informazioni interne di malloc. La prossima volta che chiamerai malloc proverà a scorrere i suoi dati per trovare spazio, colpire lo spazio sovrascritto e sarà privo di senso dal momento che lo hai sovrascritto, corrompendo l'heap.

A seconda dell'implementazione, un simile errore potrebbe essere causato anche dalla doppia liberazione.

Answer 2

Molto probabilmente, questo non è un problema nel malloc stesso. Piuttosto, questo è un problema con l'applicazione che modifica parti dell'heap che non dovrebbe.

Se stai utilizzando Linux, prova a utilizzare Valgrind per vedere quale codice sta cestinando il tuo heap.

Answer 3

La solita causa di ciò è che hai scritto sui dati che malloc () non ti dava il permesso di sovrascrivere - buffer overrun (scrittura oltre la fine dello spazio che ti era stato assegnato) o buffer underrun (scrittura prima dell'inizio del buffer).

A volte può essere causato liberando un puntatore che non è stato allocato da malloc () et al, o ri-liberando (double libering) un puntatore che è stato allocato da malloc (). Ad esempio, liberare un buffer statico è una cattiva idea; otterrai corruzione.

Dovresti presumere che il problema sia nel tuo codice - è estremamente improbabile che si tratti di un problema in malloc () et al, e piuttosto improbabile che si trovi in ??qualsiasi altra libreria che stai usando.

Answer 4

Esistono diverse cose che sono solite cause della corruzione dell'heap:

• sovrascrivendo l'allocazione di memoria (scrivendo oltre la fine del blocco allocato)
• doppia liberazione di un blocco
• usando un puntatore dopo che è stato liberato
• e ovviamente qualcosa che scrive erroneamente attraverso un puntatore che non ha nulla a che fare con un'allocazione precedente (un "colpo di ariete" o un puntatore canaglia) - questo è il caso generale che include tutto quanto sopra.

Questi problemi possono essere difficili da eseguire il debug perché la causa e l'effetto sono spesso separati da tempo e spazio (diversa area di codice). Quindi il bug non viene notato fino a quando non passa un'eternità (all'ora del computer) dopo l'esecuzione del bug che ha causato il problema.

L'uso di un heap di debug può essere molto utile nel debug di questi problemi. I compilatori di Microsoft hanno un CrtDebug heap abilitato nelle build di debug (ma può avere ulteriori elementi di configurazione impostati). Non sono sicuro di ciò che GCC ha out of the box, ma ci sono strumenti con cui ho familiarità nel passaggio come Valgrind e Electric Fence che potrebbero aiutare. Finalmente ci sono un sacco di librerie di debug dell'heap coltivate in casa che potrebbero essere utili (Google around).

Answer 5

Potresti fornire la tua dichiarazione malloc ()?

Inoltre, volevo ricontrollare che il valore restituito non sia nullo?

Oltre a non avere la memoria da allocare per cominciare, i problemi che ho riscontrato quando ho usato malloc () o new simile alla natura che hai menzionato in cui effettivamente risulta un mucchio corrotto. Di solito ho trovato alcuni "interessanti" codice altrove nel programma facendo qualcosa di simile a memcpy () con un buffer di caratteri che causa un sovraccarico del buffer e uno spazio di indirizzi alterato.

-bn