Archiv/Ladění pod UNIXEM - gdb, mtrace

Proč tohle

Toto je referát na seminář linux. Měl by pomoct lidem, kteří se chtějí naučit ladit a nechce se jim (světe div se) číst originální manuál. http://www.gnu.org/software/gdb/documentation/

Programy a chyby

Téměř každý program má svoje chyby. Chyby mohou být jak v návrhu (program tak jak je navržen nefunguje správně),

tak v realizaci (chyby v kódu). Praktičtější je ovšem chyby rozdělit na chyby "aktivní" a pasivní. Do první skupiny patří chyby patrné na první pohled, tj. program nedělá to co má, nebo padá. Do druhé skupiny patří typicky

chyby v alokaci a uvolňování paměti. Druhou skupinu je výrazně obtížnější jak detekovat, tak odhalit.

Fáze ladění kódu

Vytváření a ladění nového software v podstatě probíhá podle následujícího schématu: DOPSAL JSEM SOFTWARE

TESTUJI HO
if (V PROGRAMU JE CHYBA) goto ZACATEK LADENI else goto KONEC

ZACATEK- LADENI
STABILIZUJ CHYBU //zajisteni aby se chyba opakovala

LOKALIZUJ CHYBU //nalezeni příslušné knihovny, funkce, řádku, kde k chybám docházi
OPRAV CHYBU

goto TESTUJI HO
KONEC //program je odladěný a můžeme začít s distribucí.

Možnosti ladění kódu

Expertní čtení

Nejjednodušší je tzv "expertní čtení", aneb "Strécu, ono to nefacha, tak se do toho hleď ještě mrknout.". Tohle je jistě

možnost, ale má nevýhodu zejména psychologickou, pokud jsme udělali logickou chybu v návrhu, je poměrně těžké ji odstranit jen čtením kódu, protože se nám kód zdá v pořádku. Je to (prý) poměrně funkční v případě, že kód po nás čte

někdo jiný.

Ladící výpisy

Asi nejobecnější možnost ladění, funguje skoro vždy a skoro všude. Je dobré vypisovat na stderr, pač jinak pokud něco vypíšete na stdin a program pak "spadne", hláška se může v principu ztratit (neměla by, ale experimentálně je

tohle tvrzení ověřené). Do programu je možné zařadit výpisy na místa, kde čekáme, že by mohlo dojít k chybě.

Docela rozumné může být využít makroprocesoru překladače, napřiklad konstrukcí

#ifdef DEBUG printf ("hodnota x je : %d\n", x);

#endif

a makro DEBUG si definovat třeba při překladu

$ cc -o sorter -DDEBUG main.c A jinak v jazyce c/c++ jsou k dispozici makra

Ladící nástroje

Jsou asi nejúčinnější formou ladění, (pokud jsou dostupné), pod unixovými systémy je obvykle k dispozici pro ladění

chyb, které se projevují db, který má pod Linuxem obdobu gdb. Na skryté chyby, např v alokaci paměti jsou k dispozici nástroje typu mtrace, nebo knihovna electric fence (možná pár slov na konci).

Program gdb nám umožňuje pozorovat co se děje v "programu vevnitř", popřípadě toto dokonce měnit.

Ukázkový příklad 1.

main.c

#include <stdio.h>

#include <stdlib.h> #include "qsort.h"

int main(int argc, char ** argv){
int i;

int cisla[] = {10, 12, 2, 4, 8,7, 1, 20, 3, 25}; int * cilsa;

int arrsize = sizeof(cisla) / sizeof(int); printf("\n\nhello, Im Program for sorting.. ");

printf("\nthis is my input :");

for (i=0; i < arrsize; i++){ printf("%d ",cisla[i] );

} //tady se to celý děje.

xquickSort(cilsa, arrsize);

printf("\nthis is my output :");

for (i=0; i < arrsize; i++){ printf("%d ",cisla[i] );

} printf("\nDo you think it's OK?\n");

return 0; }

qsort.c

void xq_sort(int numbers[], int left, int right){ int pivot, l_hold, r_hold;

l_hold = left; r_hold = right;

pivot = numbers[left]; while (left < right)

{ while ((numbers[right] >= pivot) && (left < right))

  right--;
if (left != right)

{
  numbers\[left] = numbers\[right];

  left++;
}

while ((numbers\[left] <= pivot) && (left < right))
  left++;

if (left != right)
{

  numbers\[right] = numbers\[left];
  right--;

}

}

numbers[left] = pivot; pivot = left;

left = l_hold; right = r_hold;

if (left < pivot) xq_sort(numbers, left, pivot-1);

if (right > pivot) xq_sort(numbers, pivot+1, right);

}

qsort.h

extern void xquickSort(int numbers[], int array_size);

Makefile

EXECUTABLE = sorter SOURCES = main.c qsort.c

HEADERS = qsort.h OBJECTS = $(SOURCES:.c=.o)

CC = gcc CFLAGS = -ggdb -Wall

LDFLAGS = -o all: $(EXECUTABLE)

clean: rm *.o $(EXECUTABLE)

$(EXEC U T A B L E) :$ (OBJECTS) $(CC)$ (LDFLAGS) $@$ ^

$(OB J ECTS) :$ (SOURCES) $(HEADERS)

Překlad programu

Program se nám přeloží bez chyb nebo varování. Je dobré poznamenat,že program je dobé přeložit s parametrem -g,

nebo pro gdb ještě lépe -ggdb nebo -ggdb3

Ty volby se liší ve formátu ladících informací vkládaných do souboru. Do programu takto budou vkládat i některé informace "navíc",které ladícímu prostředku umožní sledovat hromadu věcí, jako jsou třeba jména proměnných a podobně Mimo jiné by šlo ještě poznamenat, že pokud program nechodí tak jak má je dobré ho přeložit s volbou

-Wall -pedantic -ansi , které nám mohou pomoci odhalit i některé neobvyklé konstrukce, často chyby.

Nástroj gdb

gdb je program pro ladění jiných programů. Programy jdou spustit jakoby "v něm". Někdo tvrdí, že je gdb nepřekonatelné... Já bych byl střízlivější, pro člověka, který není líný se něco naučit, a je schopen

překonat deprese z příkazové řádky je to mocný nástroj.

Co umožňuje gdb

Ladit přeložené programy, zkoumat core-dumpy a připojovat se k běžícím programům. Poslední možnost je docela praktická zvláště pokud chceme ladit třeba serverové aplikace.

Co se děje při startu gdb

Než začnu rozebírat přikazy pro gdb, pár slov k tomu, co se děje při startu gdb.

#gdb se rozběhne v příslušném módu (třeba s GUI, nebo v módu silent).. (o GUI nic netuším ,ale je to v manuálu)přečte si konfigurák v $HOME #zpracuje argumenty příkazové řádky

#přečte si konfigurák v aktuálním adresáři #načte historii příkazů pokud ji máme zapnutou

Konfigurační soubor

A teď k tomu konfiguráku: na Linuxu se jmenuje vždycky stejně, .gdbinit a dá se do něj nacpat spoooousta zajímavejch věcí. No třeba ta historie :

set history filename ./.gdb_history

set history save on

Docela dobry je si do konfiguráku v daném adresáři dát který soubor bude laděn file ./sorter

Nebo preloadované knihovny

set env LD_PRELOAD=/usr/lib/libefence.so

Nebo breakpointy b main

Dají se tem taky definovat makra, ale to je jiná kapitola.

Komentáře jsou jako ve skriptech - uvozené #

Spuštění gdb

celá ta nádhera se spustí pomocí příkazu gdb. Volby jsou následující :

Kdo jste chodila na základy překladačů tak určitě víte co jsou to tabulky symbolů.

Je to taková ta chytrá věc, která pojí to jak se proměnná jmenuje, a to jakou má hodnotu. Docela fajn věc pro takové ladění. Víc to tu nehodlam rozebírat pro zájemce je pěkný článek o tom, jak to funguje ve binárkách v Linuxu na téhle adrese: http://www.manualy.sk/seminar/Papers95/elf/

Jinak většinou budete startovat gdb příkazem

gdb file , kde file je jméno laděného programu.

Příkazy v gdb

No a teď zvesela na všechny možný příkazy a fíčury gdb. příkazy se zadávají ručně a gdb si je kompletuje, tj, pokud stisknete

h a

help je jediný příkaz začínající na h

tak to gdb pochopí. Pokud mu dáváte ještě vybrat,tj. je víc příkazu začínající danou sadou znaků, tak gdb vypíše možnosti.

Příkaz help

První příkaz, který je dobrý znát je vyvolání helpu.

help se vyvolá třeba h

Tenhle příkaz vypíše seznam všech skupin do kterých jsou příkazy dělené. h <skupina>

zobrazí příkazy ve skupině. h <příkaz>

zobrazí krátký popis příkazu. Ukázka:

Chceme se dozvědět jak se nastavuje breakpoint na nějakou řádku. (gdb) h

aliases -- Aliases of other commands breakpoints --

.... (gdb) h breakpoints

awatch -- Set a breakpoint for an expression break -- Set a breakpoint at specified line or function

.... (gdb) h break

nám vrátí podrobný popis jak dát breakpoint na řádku

Příkazy k použití pro započetí ladění

Pokud už nám gdb běží (a nespustili jsme ho gdb file) tak musíme specifikovat co se vlastně bude ladit.

Programu je možné nastavit argumenty a pracovní adresář.

A potom už můžeme program vesele spustit, a ladit daný program.

Ukázka:

(gdb) exec-file sorter (gdb) set arg Evzen

(gdb) cd ../ (gdb) run

Poznámka: když jsem tohle zkoušel tak se mi to jevilo, jako když gdb nenašel v souboru ladící informace,pokud byl spuštěn bez argumentù a pak mu byl dán příkaz exec-file.Že by bug v debuggeru :-) ???

Breakpointy, watchpointy a jiné zastavování běhu programu

Breakpointy a watchpointy jsou místa, kde si přejeme program zastavit.

Breakpointy jsou nastavení na nějakou funkci nebo řádek, zatímco watchpointy se vztahují k nějakým proměnným. Co je zajímavý rozdíl, je jak je debugování pomocí watchpoinů a breakpointů realizované zevnitř.

Obě skupiny mohou být realizovány hardwarově a softwarově. Hardwarové řešení vyžaduje podporu hardware, a proto není možné ho zapnout vždy.(softwarově znamená, že do programu je vložena nějaká instrukce, což samo o sobì mùže být značně nežádoucí )Pro hardwarové wp jsou poměrně značné omezení, protože využívali registry, mohou být jen dva a to ještěì stejného typu.

Breakpointy











instrukci, na které je nastaven

Watchpointy

K zastavení programu kdykoliv při změně nějaké proměnné je možno použít tzv. watchpointy.

Výjimky

Program je možno zastavit i při volání obsluhy výjimky

Ukázka:

$ gdb sorter ...

(gdb) watch cisla No symbol "cisla" in current context

(gdb) break main (gdb) break xquikSort

(run) Nastaví breakpoint na funkce main, a xquicSort, a watchpoint na proměnnou čísla. Ta hláška je logická, proměnná

cisla začne mít smysl až po vstupu do funkce main. Po spuštění se program zastaví na funkci main, poté pči inicializaci symbolu cisla.

Podmínky pro breakpointy, příkazy pro breakpointy

Každý brejkpojnt a watchpoint má svoje číslo. Vypsat jakému patří jaké jde třeba příkazem info watch

Víc toho řeknu později Poměrně praktické je definovat si podmínky pro breakpointy(tj, bp se bude chovat jako bp

pouze pokud je splněna podmínka). Syntax podmínek je převzatý z jazyka c.

Speciální forma podmínky je zastavení až po určitém počtu průchodů.

Navíc pokud jde nastavit i co se má stát, pokud program dorazí k breakpointu, popř pokud je daná podmínka splněna.

Syntax je následující:

commands [bnum] <seznam příkazů>

end

Ukázka break xquickSort if numbers == 0 #nastav breakpoint, zastav program pokud numbers == 0

commands silent #nevypisuj informace o provedených operacích

set var x = 1 #nastav nějakou proměnnou echo "je to spatny" #něco vypiš

cont #pokračuj end

Správa breakpointů (vymazání, disablování)

Příkazy clear logicky nefungují na wp.

Ukázka

(gdb) info watch Num Type Disp Enb Address What

1 watchpoint keep y cisla 2 hw wachpoint keep y i

3 breakpoint keep y 0x08048394 in main at main.c 11 (gdb) clear main

(gdb) delete 1 2 (gdb) info watch

No breakpoints or watchpoints

Krokování programu

Je-li program zastaven, může být krokován nebo pokračovat ve svém běhu. K těmto účelům slouží tyto příkazy:

Zobrazení zdrojového kódu přímo v programu gdb

Pokud opravdu pracujeme v konzoli, tak je docela praktické si prohlédnout zdrojový kód programu, pokud jsme se

nejakým způsobem zastavili na proglematickém místě. K tomuto účelu slouží příkaz list.

Ukázka (gdb)search printf

23 printf("\nthis is my input: ");

Co je docela dobrý, že tímhle se posune kontext gdbcka na příslušný řádek, a tedy pokud máme zapnutou history file, tak se dá ten příkaz zase vyvolat a může se jet k dalšímu takovému symbolu.

Zobrazování kódu programu v asembleru

Pro opravdové labužníky je možnost vypisovat si program přímo v asembleru. Tahle možnost pracuje jen pokud je program přeložen s ladícími informacemi(nevíte někdo proč??). Pokud nemáme ladící informace k dispozici, můžeme ještě zkusit vypisovat přímo paměť a nechat jí interpretovat jako instrukce, ale to je opravdu hodně pokročilá a nejistá věc.

Zkoumání obsahu paměti programu

Formát dat

gdb musí v některých případech vědět, v jakém formátu má zobrazit data. toto shrnuje následující tabulka:

Délky datové buňky

Pokud vypisujeme data z adresy, tak je potřeba definovat, jak dlouhá data chceme interpretovat.

Délky můžeme nastavit na:

Zobrazování hodnot proměnných (print)

Nejčastěji se budeme chtít zobrazit proměnnou a její hodnotu. K tomu nám poslouží příkazy:

Automatické zobrazování hodnot proměnných (display)

Pokud tuto akci chceme automatizovat, tj pokud chceme nějaká data zobrazit po každém zastavení programu na bp nebo wp je pro nás připraven příkaz display

Přímý přístup k datům (x, eXamine)

Nejsurovější možností přístupu k datům programu je příkaz x, který sahá doslova a do písmene přímo na data.

Ukázka v programu máme pole integerů. pokud chceme vypsat celé pole použijeme příkaz print

(gdb) print cisla

$2 = {10, 12, 2, 4, 8, 7, 1, 20, 3, 25} a teď k nim přistoupíme pomocí příkazu x

(gdb) x/10uw $2

Práce s daty na zásobníku, trasování

Pro většinu z Vás asi nebude překvapením, že realizace programu (většinou) probíhá pomocí zásobníku.

Při volání funkce se na zásobník uloží její parametry, návratovou hodnotu, lokální proměnné a adresu, na které je funkce právě vykonávána. Čím později je funkce volána, tím blíže k vrcholu zásobníku jsou tyto

údaje uloženy. Stack frame je název pro tato data vážící se k právě jedné volané funkci. Při spuštění

programu existuje pouze jeden stack frame pro funkci main. Při každém volání další funkce vzniká nový stack frame. Stack frame je jednoznačně určen svojí adresou. V době vykonávání stack framu je jeho adresa

obvykle uchovávána ve frame pointer registru. Tolik teorie,a teď jak se to dá použít

Gdb přiřazuje každému stack framu unikátní číslo, nulu pro nejvnitřnější sf, tj. ten, který byl volán naposledy. Jednička náleží sf, ze kterého byl poslední volán, atd.

U některých kompilátorů je možno vypnout používání sf. Gdb má omezené možnosti pro ladění takovýchto programů. Následuje seznam příkazů pro manipulaci se stack framy:


argument uveden, vytiskne se aktuální sf

K nucenému návratu z funkce lze použít příkaz return expr. Příkaz danou funkci nedokončí, ale zruší daný stack frame

a všechny, které z něj byly volány. Je-li uveden výraz expr, vyhodnotí se a výsledek je použit jako návratová hodnota. Následuje návrat za místo volání dané funkce.

Ukázka

(gdb) run Starting program: /afs/ms.mff.cuni.cz/u/p/popxt3am/prg_unix/ladeni/nullptr-lad

Program received signal SIGSEGV, Segmentation fault.

0x4655d981 in strtof_l () from /lib/libc.so.6 (gdb) where

#0 0x4655d981 in strtof_l () from /lib/libc.so.6 #1 0x4655af43 in __strtod_internal () from /lib/libc.so.6

#2 0x4655712d in atof () from /lib/libc.so.6 #3 0x080483d4 in main (argc=1, argv=0x9fce6044) at nullptr.c:4

(gdb) frame 3 #3 0x080483d4 in main (argc=1, argv=0x9fab9cb4) at nullptr.c:4

4 printf("1/%f is %f\n", 1/atof(argv[1])); (gdb) print argv[1]

$1 = 0x0 (gdb)

Ladění programu v asembleru -pro labužníky

Tahle pasáž se týká toho, jak ladit program, ve kterém nejsou ladící informace. To je hodně pokročilá věc, která skýtá mnohá úskalí. Popravdě, tohle jsem já nikdy nepoužil a bohapustě jsem to opsal. Svým způsobem nevím, proč jsou potřeba ladící informace na krokování programu v asembleru.Ale poradit si jde.

Nejdříve je potřeba zjistit, od které adresy se program spouští. V Gdb lze vstupní adresu zjistit příkazem info target, který kromě jiných údajů vypíše i vstupní adresu - entry point.

Je-li známa adresa, od které je program vykonáván, nastaví se na ni breakpoint a program se spustí. Nyní je možno program krokovat, nastavovat breakpointy, ale nefunguje příkaz

disassemble. Ten vyžaduje ladící informace ( je-li možno v tomto případě příkaz disassemble zprovoznit, nevím o tom a uvítám případné připomínky).

Krokuje se příkazy si nebo ni. Málokdo však zná binární kód krokovaného programu, aniž by jej předtím viděl. Jak tedy zobrazit výpis v assembleru?

K tomuto účelu dobře poslouží příkaz x (eXamine).

x/3i $pc

pc je název registru čítače adresy (program counter) a příkaz x bude zkoumat obsah adresy v něm obsažené parametr i říká, že obsah zkoumané adresy bude zobrazen jako instrukce assembleru číslo 3 určuje, že budou zobrazeny 3 instrukce od adresy v pc

Příkaz x funguje jednorázově, pro zobrazování instrukce po každém kroku lze použít příkaz display.

disp /3i $pc po každém zastavení programu jsou vypsány tři instrukce od adresy v pc

disp /5i $pc-2 bude vypisovat 2 instrukce před aktuální adresou, instrukci na aktuální adrese a 2 instrukce za ní.

!! toto funguje trochu jinak. výraz $p c - 2 s ah \overset{a}{ˊ} d o p am \overset{e}{ˇ} t i d v abaj t y p \overset{r}{ˇ} e d ak t u \overset{a}{ˊ} l n \overset{ı}{ˊ} h o d n o t u \overset{c}{ˇ} \overset{ı}{ˊ} t a \overset{c}{ˇ} e in s t r u k c \overset{ı}{ˊ} . P ro t o \overset{z}{ˇ} e in s t r u k ce maj \overset{ı}{ˊ} r \overset{u}{˚} z n o u d \overset{e}{ˊ} l k u, t \overset{e}{ˊ} m \overset{e}{ˇ} \overset{r}{ˇ} nik d yse n e t re f \overset{ı}{ˊ} k ore k t n \overset{e}{ˇ} na z a \overset{c}{ˇ} \overset{a}{ˊ} t e kin s t r u k ce ./3 i$ pc funguje správně, protože vypisuje 3 instrukce od aktuální hodnoty čítače instrukcí a jejich délku si zjistí sám korektně.

Obsahy základních registrů vypíše příkaz info registers a obsahy všech registrů pak příkaz info all-registers. Jména registrů jsou závislá na platformě, Gdb však zavádí 4 jména, která by měla fungovat na všech platformách. Jsou to

Na registry se lze odkazovat jejich jménem jako na běžnou proměnnou. Před názvem však musí být uveden znak "$". Měnit obsahy registrů je možno příkazem

set $registr = hodnota nebo příkazem print

$registr = hodnota ,který zároveň vytiskne novou hodnotu. Např. změnou hodnoty registru pc se skočí na jinou adresu, ale program je stále zastaven.

Proměnné

K proměnným v programu lze přistupovat přímo jejich jménem. Dereference se zapisuje jako v C pomocí znaku "*". Změnit jejich hodnotu lze příkazy print prom=hodnota a set var prom=hodnota. Pro různé účely je možno definovat nové proměnné v prostředí Gdb. To se provede příkazem set $prom=hodnota. Vlastní proměnné vypíše příkaz show convenience. Příklad použití vlastních proměnných:

Ukázka

(gdb) set

ParseError: KaTeX parse error: Undefined control sequence: \[ at position 25: …gdb) print pole\̲[̲

i++]->prvni

Ukázka

V jednom z předchozích odstavců jsem cosi povídal o výpisu paměti. použil jsem tam to, že jsem znal velikost pole intů.

pokud bych jí chtěl zjistit, můžu požít příkaz

(gdb) set $v e l ik os t = s i zeo f (c i s l a) /4 (g d b) p r in t$ velikost

$4 = 10

Zápis hodnoty na konkrétní adresu lze provést příkazem set {type}addr. Ve složených závorkách je uveden typ hodnoty (a tím i velikost). Typy jsou stejné jako v C.

Definování maker

V Gdb je možno definovat uživatelské příkazy včetně příkazů s argumenty. Slouží k tomu následující příkaz:

define prikaz

Počátek definice příkazu prikaz. Mohou následovat příkazy gdb, vždy jeden na řádek. Definici ukončuje řádka s příkazem end.

K argumentům příkazu lze přistupovat pomocí proměnných $a r g 0,$ arg1, atd., kde $arg0 obsahuje hodnotu prvního argumentu. Je-li příkazu předáno méně argumentů, než je v definici použito, gdb vypíše chybu "Missing argument x in user function". V příkazu mohou být i podmínky:

if expr

Je-li splněna podmínka expr, vykonají se příkazy na následujících řádkách. Příkaz if může být následován řádkou s příkazem else. Seznam příkazů pro blok if [else] se ukončí řádkou s příkazem end. until expr

Seznam příkazů za příkazem while, ukončený řádkou s příkazem end, se bude vykonávat, dokud výraz expr bude vyhodnocován jako pravdivý.

Jsou k dispozici i některé další kostrukce, jako printf, a echo.

Uživatelský příkaz může být dokumentován příkazem document prikaz.

Příkaz už musí být definován. Text přiřazený příkazu je pak dostupný v helpu. Celé sady příkazů jdou načíst pomocí příkazu

source.

Prohlédnout příkazy, kterými je definován nějaký uživatelský příkaz, lze příkazem show user prikaz. Mimochodem tohle je jedna z věcí, ve které si myslím, že je GDB silnější než grafické ladící nástroje.

Ukázka

define vypis_cisla if ($arg0 == 1)

print cisla else

print cilsa end

end

(gdb) vypis_cisla 1 $2 = {10, 12, 2, 4, 8, 7, 1, 20, 3, 25}

Ukázka session -odladění vzorového příkladu

To máte za domácí úkol, stejně jsem to už natáhl víc, než jsem chtěl :-)

Nástroje pro kontrolu dynamicky alokované paměti

Protože ne vždy víme, kolik místa budeme v programu potřebovat, je jazyk C obohacen o funkce malloc() a free() pro alokaci a dealokaci paměti za běhu programu. Bohužel, s dynamickou pamětí je problém, konkrétně jde o to, že

program sáhne na paměť, kterou nemá alokovanou, tj. způsobí chybu segmentace
program neuvolňuje paměť a sám se utopí ve množstí alokované paměti, na kterou nevede žádný pointer (popř. způsobí problém systému)

Obecně by mělo platit následující

program nikdy nepřistoupí k paměti, kterou nemá alokovanou
program nikdy nepřesáhne meze paměti, kterou má alokovanou
počet volání malloc a free je vždy stejný

Co je smutné je fakt, že se na chyby v dynamicky alokované paměti špatně přichází

Samozřejmě, že jsou postupy a knihovny, které se tento problém snaží řešit. Já tady popíšu následující tři.

MALLOC_CHECK_, aneb řešení ze standardní knihovny

MALLOC_CHECK_ je systémová proměnná, pokud ji nastavíme na 2, program se zastaví pokud

dojde k zápisu (ne přístupu !!) bezprostředně před začátek alokované paměti
dojde k dvojí dealokaci

Ukázka

Popisuje program alokátor, který se pokusí dvakrát dealokovat alokovanou paměť $ export MALLOC_CHECK_=2

$ ./alokator Aborted(core dumped)

mtrace

mtrace je výborný nástroj,ale má drobnou nevýhodu... program musí skončit normálně (tj. regulérním opuštěním funkce main), jinak tento nástroj nefunguje(nebo fungovat nemusí). Jde použít na

detekci selhání dealokace alokované paměti
detekci dealokace paměti, která nebyla alokována

Používá se násldujícím způsobem:

Specifikujeme systémovou proměnnou

MALLOC_TRACE

Do laděného kódu se vloží

#include <mcheck.h>

Na začátku funkce main() se volá funkce mtrace
No a ve specifikovaném souboru budou informace o chybných dealokacích

Ukázka $export MALLOC_TRACE=mlog.log

$./ a l o ka t or 2$ cat mlog.log

00000000000 Free 1 was never alloc'd alokator2.c:20 Memory not freed

Address    Size   Caller

0x08049d48 0xc at alokator2.c:15

knihovna electric fence

Tato knihovna zastaví program tam, kde dojde k přístupu mimo alokovanou paměť.

Detekuje to následující věci

Zápis a čtení před a za alokovanou paměť
Zápis a čtení do paměti, která byla dealokována
Alokaci paměti nulové velikosti

Pracuje v podstatě tak, že do paměti nastřílí náhodnou špínu a program pak spadne hned a ne až jednou, za mnoho dní a nocí :-). Teda tohle se to traduje, ale ono to dělá ještě i něco navíc.

Na každý kousek paměti se alokují alespoň dvě stránky paměti paměť kterou jsme opravdu chtěli se umístí do konce první stránky, a knihovna hlídá jestli nechceme psát někam jinam do těch stránek. Z toho ovšem plyne poměrně nepříjemná věc, že tahle kráska spotřebovává strašně moc paměti. Proto používat s mírou a pouze pro ladící účely.

V každém případě, pokud uděláte něco z popsaných věcí tak to prostě spadne.

Segmentation fault

A kde to spadlo se můžeme podívat pomocí gdb Docela pěkně jde kombinovat s gdb přímo, viz ta pasáž o konfiguráku.

Její použití spočívá v tom, že ji slinkujeme s programem gcc -c -Wall -pedantic alokator3.o -o alokator3 -lefence

valgrind

viz *http://www.valgrind.org/docs/manual/quick-start.html

*wen:Valgrind *http://www.faqs.org/docs/Linux-HOWTO/Valgrind-HOWTO.html

Category:Referáty