søndag 9. november 2008

Heng i Internet Explorer.

Har vært en stund siden det har vært noe skikkelig feilsøkings stoff, men her skal jeg da Internet Explorer hengte seg fullstendig (Mao ingen vinduer ble oppdatert) bestemte jeg meg for å starte Windbg og se hva som forårsaket problemet. Her kan du se hvilken beskjed når jeg første prøvde å koble meg til prosessen med debuggeren:

Break-in sent, waiting 30 seconds...
WARNING: Break-in timed out, suspending.
This is usually caused by another thread holding the loader lock


Debuggeren har to måter å huke seg på en prosess - først prøver den å injisere en tråd som brukes til å gjøre et såkalt "break in" i prosessen - hvis denne tråden ikke har svart innen 30 sekunder vil debuggeren supsendere alle trådene og dermed stoppe prosessen på dette viset.

La oss hvilke Krtiske Seksjoner i systemet som er låst via !locks

0:004> !locks

CritSec ntdll!LdrpLoaderLock+0 at 7c97c0d8
LockCount 8
RecursionCount 1
OwningThread d98
EntryCount 74
ContentionCount 74
*** Locked

CritSec urlmon!g_mxsMedia+0 at 44604790
LockCount 0
RecursionCount 1
OwningThread d98
EntryCount 1
ContentionCount 1
*** Locked

Vi ser da et den kritiske at vi har to kritiske seksjoner hvorav den ene blir ventet på hele 8 tråder. ntdll!LdrpLoaderLock+0 er låsen til Dllmain som brukes til å installere og fjerne dll filer. Dllmain skal også informeres om eventuelle nye tråder i prosessen slik at tråder vil registere seg ved Dllmain ved DLL_THREAD_ATTACH.
La oss ta en titt på tråden som injiseres av Windbg:

22 Id: b7c.73c Suspend: 1 Teb: 7ffdc000 Unfrozen
ChildEBP RetAddr Args to Child
0124fc0c 7c90e9c0 7c91901b 00000070 00000000 ntdll!KiFastSystemCallRet
0124fc10 7c91901b 00000070 00000000 00000000 ntdll!ZwWaitForSingleObject+0xc
0124fc98 7c90104b 0197c0d8 7c927357 7c97c0d8 ntdll!RtlpWaitForCriticalSection+0x132
0124fca0 7c927357 7c97c0d8 0124fd2c 00000004 ntdll!RtlEnterCriticalSection+0x46
0124fd18 7c90eac7 0124fd2c 7c900000 00000000 ntdll!_LdrpInitialize+0xf0
00000000 00000000 00000000 00000000 00000000 ntdll!KiUserApcDispatcher+0x7


Vi kan se at tråden ikke er ferdig installert enda og venter på at den kritiske seksjonen skal frigjøres. Vi skal se på tråden som eier den krtiske seksjonen men først skal vi bruke !runaway for å se hvilke tråder som har vært mest aktive i prosessen:

0:004> !runaway
User Mode Time
Thread Time
4:d98 0 days 0:00:17.375
20:d84 0 days 0:00:02.562
15:244 0 days 0:00:00.843
0:5dc 0 days 0:00:00.765
18:170 0 days 0:00:00.171
17:e08 0 days 0:00:00.171
14:108 0 days 0:00:00.078
6:e4c 0 days 0:00:00.046
12:c4c 0 days 0:00:00.031
13:d48 0 days 0:00:00.015
22:73c 0 days 0:00:00.000
21:a5c 0 days 0:00:00.000
19:338 0 days 0:00:00.000
16:640 0 days 0:00:00.000
11:350 0 days 0:00:00.000
10:b58 0 days 0:00:00.000
9:a58 0 days 0:00:00.000
8:aec 0 days 0:00:00.000
7:c24 0 days 0:00:00.000
5:dc0 0 days 0:00:00.000
3:990 0 days 0:00:00.000
2:b8c 0 days 0:00:00.000
1:f60 0 days 0:00:00.000


Vi ser at på topp ligger tråden som eier den krtiske seksjonen men på 2, plass ligger en annen tråd som har brukt ganske mye av tiden også - vi skal se på den senere men først skal vi se på tråden som både har brukt mesteparten av tiden til scheduleren og som eier den kritiske seksjonen:

4 Id: b7c.d98 Suspend: 1 Teb: 7ffd8000 Unfrozen
ChildEBP RetAddr Args to Child
0166fe0c 7e41daf6 44577b30 00040572 001931d8 ntdll!KiFastSystemCallRet
0166fe24 44577adc 00000d98 00000000 00000000 USER32!NtUserDestroyWindow+0xc
0166fe40 44551d9f 44604820 00000000 0166fe64 urlmon!DoThreadCleanup+0x117
0166fe50 44551d86 00000001 00000001 00000000 urlmon!DoThreadCleanup+0xf
0166fe64 44551b86 44550000 00000003 00000000 urlmon!TlsDllMain+0x2a
0166fe84 44551a7f 44550000 00000003 00000000 urlmon!DllMain+0x17e
0166fee4 7c9011a7 44550000 00000003 00000000 urlmon!_initterm_e+0x12b
0166ff04 7c919213 445519f1 44550000 00000003 ntdll!LdrpCallInitRoutine+0x14
0166ff7c 7c80c096 0012e490 0012e5b8 0018ea28 ntdll!LdrShutdownThread+0xd7
0166ffb4 7c80b688 00000000 0012e490 0012e5b8 kernel32!ExitThread+0x3e
0166ffec 00000000 447ee424 0018ea28 00000000 kernel32!BaseThreadStart+0x3c

Vi ser at kernel32 har bedt om at tråden stenges og det kaller da inn i urlmon som benytter funksjonene i Dllmain for å rense opp sine objekter i tråden som skal avsluttes. urlmon brukes tilegg som benytter seg av OLE32 så kan det være noe galt med et OLE32 objekt? La oss se på den tråden som brukte nest mest av cpu-tiden i user mode:

20 Id: b7c.d84 Suspend: 1 Teb: 7ff9b000 Unfrozen
ChildEBP RetAddr Args to Child
0d2cf6e4 7c90e9ab 7c8094e2 00000002 0d2cf710 ntdll!KiFastSystemCallRet
0d2cf6e8 7c8094e2 00000002 0d2cf710 00000001 ntdll!ZwWaitForMultipleObjects+0xc
0d2cf784 7e4195f9 00000002 0d2cf7ac 00000000 kernel32!WaitForMultipleObjectsEx+0x12c
0d2cf7e0 77502235 00000001 0d2cf828 000003e8 USER32!RealMsgWaitForMultipleObjectsEx+0x13e
0d2cf808 7750235c 0d2cf828 000003e8 0d2cf838 ole32!CCliModalLoop::BlockFn+0x80
0d2cf830 77516749 ffffffff 0d2cf928 0d2cf860 ole32!ModalLoop+0x5b
0d2cf840 775f1f01 0018ee18 0d2cf928 00000000 ole32!SwitchSTA+0x21
0d2cf860 775f109a 0d2cf928 00209164 0d2cf984 ole32!CRpcChannelBuffer::SwitchAptAndDispatchCall+0xd1
0d2cf940 77502409 00209164 0d2cfa54 0d2cfa44 ole32!CRpcChannelBuffer::SendReceive2+0xb9
0d2cf95c 775023b2 0d2cfa54 0d2cfa44 00209164 ole32!CCliModalLoop::SendReceive+0x1e
0d2cf9c8 77500414 00209164 0d2cfa54 0d2cfa44 ole32!CAptRpcChnl::SendReceive+0x6f
0d2cfa1c 77ef3db5 00209164 0d2cfa54 0d2cfa44 ole32!CCtxComChnl::SendReceive+0x113
0d2cfa38 77ef3ead 069a696c 0d2cfa80 0600015b RPCRT4!NdrProxySendReceive+0x43
0d2cfe14 77ef3e42 774d6218 774d92ca 0d2cfe4c RPCRT4!NdrClientCall2+0x1fa
0d2cfe34 77e8a7f3 00000010 00000005 0d2cfe5c RPCRT4!ObjectStublessClient+0x8b
0d2cfe44 77501410 069a696c 00000002 0721fb50 RPCRT4!ObjectStubless+0xf
0d2cfe5c 775013b1 069a696c 0018ee18 00000002 ole32!RemoteReleaseRifRefHelper+0x84
0d2cfe84 77500052 069a696c 0018ee18 00000002 ole32!RemoteReleaseRifRef+0x74
0d2cfedc 774ffe4b 06fbce04 06fbce00 00000000 ole32!CStdMarshal::DisconnectCliIPIDs+0x200
0d2cff04 774fd878 00000002 06fbcea8 06fbce00 ole32!CStdMarshal::Disconnect+0x178

Og vi ser at denne tråden driver og rydder opp i OLE32 objekter og den står og venter på to objekter-la oss se nærmere på disse:

0:004> dd 0d2cf710
0d2cf710 0000088c 00000c40 00000001 00000000
0d2cf720 00000000 00000010 00000000 0000022d
0d2cf730 00000014 00000001 00000000 00000000
0d2cf740 00000010 ff676980 ffffffff 7ff9b000
0d2cf750 7ffde000 7ff9b000 0d2cf78c 0d2cf744
0d2cf760 0d2cf710 0d2cf984 00000002 0d2cf704
0d2cf770 06ac780c 0d2cfe04 7c839aa8 7c8095d8
0d2cf780 00000000 0d2cf7e0 7e4195f9 00000002


dd dumper da atlså arrayet med referasene til de to objektene - la oss titte nærmere på disse:

0:004> !handle 00000c40 7
Handle c40
Type Event
Attributes 0
GrantedAccess 0x1f0003:
Delete,ReadControl,WriteDac,WriteOwner,Synch
QueryState,ModifyState
HandleCount 2
PointerCount 5
Name

0:004> !handle 0000088c 7
Handle 88c
Type Event
Attributes 0
GrantedAccess 0x1f0003:
Delete,ReadControl,WriteDac,WriteOwner,Synch
QueryState,ModifyState
HandleCount 2
PointerCount 4
Name


Vi ser da at det dreier seg om to synkroniseringsobjekter-ved å bruke process explorer fant jeg ut at det ene var signaled mens det andre var såkalt non-signaled og dermed det mest interessante. Handlecount på 2 betyr at en annen struktur fremdeles referer til den la oss se om vi kan finne moduler i minnet som har en referanse til denne addressen:

07f32418 0000088c
07f3241c 0116bc21
07f32420 fffe1800
07f32424 23ffff14
07f32428 fd150003
07f3242c 04035bff SkypeIEPlugin!DllRegisterServer+0x6fef


07f910f8 633a0c16 jscript!MUTX::Enter+0x38
07f910fc 00000010
07f91100 00000000
07f91104 0000088c

SkypeIEplugin hadde også vært refert som de siste funksjonene på stakken:

0d2bdc38 04076aba SkypeIEPlugin!DllRegisterServer+0x47eaa
0d2bdc3c 04076ac2 SkypeIEPlugin!DllRegisterServer+0x47eb2
0d2bdc40 881f6a96
0d2bdc44 00000000
0d2bdc48 00000078
0d2bdc4c 040c3620 SkypeIEPlugin!DllRegisterServer+0x94a10
0d2bdc50 7c90d592 ntdll!ZwClose+0xc
0d2bdc54 00000000
0d2bdc58 00000003
0d2bdc5c 000000a8
0d2bdc60 04062ac4 SkypeIEPlugin!DllRegisterServer+0x33eb4
0d2bdc64 04076af2 SkypeIEPlugin!DllRegisterServer+0x47ee2
0d2bdc68 042627dc
0d2bdc6c 04062bbc SkypeIEPlugin!DllRegisterServer+0x33fac
0d2bdc70 00000003
0d2bdc74 04062bb3 SkypeIEPlugin!DllRegisterServer+0x33fa3
0d2bdc78 881f6a52
0d2bdc7c 00000000
0d2bdc80 040c1130 SkypeIEPlugin!DllRegisterServer+0x92520
0d2bdc84 04260000
0d2bdc88 00000000
0d2bdc8c 00000000
0d2bdc90 0d2bdc78
0d2bdc94 0d2bdcf0
0d2bdc98 0d2bdcf0
0d2bdc9c 00015be0
0d2bdca0 00000015
0d2bdca4 0d2bdc00
0d2bdca8 04062bb3 SkypeIEPlugin!DllRegisterServer+0x33fa3
0d2bdcac 0d2bdcec
0d2bdcb0 7c90ee18 ntdll!_except_handler3
0d2bdcb4 7c910570 ntdll!CheckHeapFillPattern+0x64
0d2bdcb8 ffffffff
0d2bdcbc 7c91056d ntdll!RtlFreeHeap+0x647
0d2bdcc0 04056857 SkypeIEPlugin!DllRegisterServer+0x27c47
0d2bdcc4 04260000
0d2bdcc8 00000000
0d2bdccc 04056876 SkypeIEPlugin!DllRegisterServer+0x27c66
0d2bdcd0 881f6a06
0d2bdcd4 000089be
0d2bdcd8 0d2cf12c
0d2bdcdc 000089be
0d2bdce0 000089be
0d2bdce4 0d2bdcd0
0d2bdce8 0d2bdcd4
0d2bdcec 0d2cf0d8
0d2bdcf0 04055be0 SkypeIEPlugin!DllRegisterServer+0x26fd0
0d2bdcf4 813f07aa
0d2bdcf8 fffffffe
0d2bdcfc 04056876 SkypeIEPlugin!DllRegisterServer+0x27c66
0d2bdd00 03ff2782 SkypeIEPlugin+0x2782
0d2bdd04 04268e10
0d2bdd08 04273780
0d2bdd0c 04001de6 SkypeIEPlugin+0x11de6


Det falt seg derfor naturlig å anta at det var SkypeIEplugin som var problemet og den prøvde sannsynligvis å benytte seg av Dllmain for registere dll filen mens Dllmain sin aksess var låst til en kritisk seksjon som følge av at urlmon prøvde å rydde opp OLE32 objekter brukt av SkypeIEPlugin, siden jeg ikke bruker denne Plugin'en bare fjernet jeg autolastingen av dll'en ved å bruke Autoruns.


Som sagt før, er det noe du lurer på angående dette er det bare å spørre!

torsdag 6. november 2008

I/O-systemet i Windows XP

I/O-systemet i Windows består av flere komponenter som sammen sørger for å håndtere maskinvare og tilerettelegge et grensesnitt slik at applikasjoner og systemet kan kommunisere med maskinvare. I/O-systemet er delt i 3 hoveddeler som er kontrollert av henholdvis I/O-manageren, PNP-manageren og Power manageren. Jeg skal nå gjennomgå hva hver enkelt av disse komponentene gjør.

I/O-Manageren.
I/O-manageren sørger for å definere et rammeverk hvor I/O-forespørslene kan dirigeres til sine respektive drivere som igjen kan håndtere forespørselen. I/O-trafikken blir håndtert pakkevis, og de aller fleste I/O-forespørsler er representert via en IRP (I/O Request Packet)-unntaket ligger altså i fast I/O som da altså ikke bruker IRP-pakker.
IRP-pakker blir generert av I/O-manageren og disse pakkene beskriver da altså en unik I/O operasjon. Deretter vil I/O-manageren gi en peker IRP-pakken til den korrekte driveren slik at den kan lese innholdet i IRP-pakken og utføre operasjonen som er beskrevet i pakken. Når denne operasjonen er ferdigstillt returnerer driveren IRP-pakken til I/O manageren slik at den kan enten fjerne pakken hvis I/O operasjonen er ferdig eller eventuellt sende pakken videre til neste driver for videre prosessering.

Flyten i en typisk I/O forespørsel:

1.Applikasjon i User-Mode kaller på en funksjon i Windows API-et som krever I/O overføring.

2.Denne funksjonen kaller da inn i I/O systemets service API som har funskjoner for forskjellige I/O operasjoner slik som å lese til en fil eller lese fra en fil.

3.Deretter vil I/O manageren finne ut hvilken driver som kan håndtere den forespurte I/O operasjonen og deretter overføre kontrollen til enhetsdrivreren.

4.Enhetsdriveren vil da be HAL om å utføre I/O opp mot maskinvaren hvor på HAL vil lese/skrive til de aktuelle I/O portene og registrene til maskinvaren.

Plug and Play-manageren. (PnP).
Plug and Play i Windows blir håndtert av PnP-manageren som da skal automatisk kjenne igjen maskinvare og kunne tilpasse seg endrende maskinvarekonfigurasjon. For at Plug and Play skal fungere skikkelig krever det at både maskinvare, drivere og operativsystemet er PnP-kompatibelt. PnP i Windows har følgende egenskaper.


  • PnP-manageren kjenner automatisk igjen installerte enheter og enumerer dem ved oppstart og vil også kunne detektere fjerning og installering av ny maskinvare mens systemet kjører
  • PnP-manageren vil automatisk allokere ressursene som er nødvendig for hver enkelt enhet (Avbrudd, I/O-minne, I/O registere eller buss-spesifikke ressurser.) Siden du kan legge til og fjerne maskinvare mens systemet kjører må også PnP manageren sørge for å kunne dynamisk endre ressurene for å tilfredstille de kravene som maskinvaren stiller.
  • PnP-manageren må også kunne laste inn korrekte drivere for den spesifikke enheten ved å sammenlinge spesifikasjonene på enhetene med de definert i driveren og deretter undersøke om driveren har egenskaper for å håndtere maskinvaren. Hvis driveren godkjennes vil PnP-manageren be I/O-mangeren om å laste den.

Power-manageren. Power-manageren håndterer strømtyring for systemet og for maskinvaren. For at dette skal fungere skikkelig må både maskinvare og BIOS samsvare med ACPI (Advanced Configuration and Power Interface)-standarden. Denne standarden spesifiser 6 forskejellige strømtilstander for systemet og 4 for maskinvaren. Systemets tilstander er definert gjennom S0 til S5 hvor S0 er fullstendig på og S5 er fullstendig av. Maskinvaren er definert gjennom D0 til D3 hvor D0 er fullstendig på og D3 er fullstendig av. Tilstandede imellom spesifiser strømsparingstilstander slik som hvile- og dvalemodus. Power manageren sørger for å styre systemet mens driverne sammarbeider med Power-manageren om å styre maskinvaren.

I/O-systemet via Windbg.

Du kan også bruke Windbg for å undersøke nærmere hvordan I/O-systemet oppererer. Du kan feks dumpe ut et trådobjekt og se på IRP-listen dens for å se IRP-pakker som ikke er ferdgistillt.


kd> !irp 822aa318
Irp is active with 1 stacks 1 is current (= 0x822aa388)
No Mdl: System buffer=82010c18: Thread 82284868: Irp stack trace.
cmd flg cl Device File Completion-Context
>[ e, 0] 5 0 82290a50 82302f90 00000000-00000000
\FileSystem\AvgMfx86
Args: 00000238 00000238 53492424 00000000


Vi kan dermed se at driveren som er ansvarlig for å håndtere denne pakken er AvgMfx86 og funksjoner den skal kjøre er definert som operasjon e.
Vi kan sjekke hvilken operasjon dette korresponderer til ved å bruke !drvobj opp mot driveren med en verbosity på 7:

kd> !drvobj AvgMfx86 7
Driver object (8224fbe0) is for:
\FileSystem\AvgMfx86
Driver Extension List: (id , addr)

Device Object list:
82290a50

DriverEntry: f88d1846 avgmfx86
DriverStartIo: 00000000
DriverUnload: f844ef08 fltmgr!FltpMiniFilterDriverUnload
AddDevice: 00000000

Dispatch routines:
[00] IRP_MJ_CREATE f88ce38e avgmfx86+0x38e
[01] IRP_MJ_CREATE_NAMED_PIPE 804fa87e nt!IopInvalidDeviceRequest
[02] IRP_MJ_CLOSE f88ce38e avgmfx86+0x38e
[03] IRP_MJ_READ 804fa87e nt!IopInvalidDeviceRequest
[04] IRP_MJ_WRITE 804fa87e nt!IopInvalidDeviceRequest
[05] IRP_MJ_QUERY_INFORMATION 804fa87e nt!IopInvalidDeviceRequest
[06] IRP_MJ_SET_INFORMATION 804fa87e nt!IopInvalidDeviceRequest
[07] IRP_MJ_QUERY_EA 804fa87e nt!IopInvalidDeviceRequest
[08] IRP_MJ_SET_EA 804fa87e nt!IopInvalidDeviceRequest
[09] IRP_MJ_FLUSH_BUFFERS 804fa87e nt!IopInvalidDeviceRequest
[0a] IRP_MJ_QUERY_VOLUME_INFORMATION 804fa87e nt!IopInvalidDeviceRequest
[0b] IRP_MJ_SET_VOLUME_INFORMATION 804fa87e nt!IopInvalidDeviceRequest
[0c] IRP_MJ_DIRECTORY_CONTROL 804fa87e nt!IopInvalidDeviceRequest
[0d] IRP_MJ_FILE_SYSTEM_CONTROL 804fa87e nt!IopInvalidDeviceRequest
[0e] IRP_MJ_DEVICE_CONTROL f88ce38e avgmfx86+0x38e
[0f] IRP_MJ_INTERNAL_DEVICE_CONTROL 804fa87e nt!IopInvalidDeviceRequest
[10] IRP_MJ_SHUTDOWN 804fa87e nt!IopInvalidDeviceRequest
[11] IRP_MJ_LOCK_CONTROL 804fa87e nt!IopInvalidDeviceRequest
[12] IRP_MJ_CLEANUP 804fa87e nt!IopInvalidDeviceRequest
[13] IRP_MJ_CREATE_MAILSLOT 804fa87e nt!IopInvalidDeviceRequest
[14] IRP_MJ_QUERY_SECURITY 804fa87e nt!IopInvalidDeviceRequest
[15] IRP_MJ_SET_SECURITY 804fa87e nt!IopInvalidDeviceRequest
[16] IRP_MJ_POWER 804fa87e nt!IopInvalidDeviceRequest
[17] IRP_MJ_SYSTEM_CONTROL 804fa87e nt!IopInvalidDeviceRequest
[18] IRP_MJ_DEVICE_CHANGE 804fa87e nt!IopInvalidDeviceRequest
[19] IRP_MJ_QUERY_QUOTA 804fa87e nt!IopInvalidDeviceRequest
[1a] IRP_MJ_SET_QUOTA 804fa87e nt!IopInvalidDeviceRequest
[1b] IRP_MJ_PNP 804fa87e nt!IopInvalidDeviceRequest

Vi kan se at operasjonen 0E korresponder til en intern funksjon i driveren. Vi kan også se standard rutinene som I/O-manageren definerer for driveren.

Vi kan også ta en titt på Strømfunksjonalitetene for systemet ved å bruke !pocaps

kd> !pocaps
PopCapabilities @ 0x80560d20
Misc Supported Features: PwrButton SlpButton Lid S3 S4 S5 HiberFile FullWake
Processor Features: Thermal Throttle (MinThrottle = 15%, Scale = 0%)
Disk Features: SpinDown
Battery Features: BatteriesPresent
Battery 0 - Capacity: 0 Granularity: 0
Battery 1 - Capacity: 0 Granularity: 0
Battery 2 - Capacity: 0 Granularity: 0
Wake Caps
Ac OnLine Wake: Sx
Soft Lid Wake: Sx
RTC Wake: S4
Min Device Wake: Sx
Default Wake: Sx

Det er del flere kommandoer som kan brukes, men HTML-genereringen til denne Javacript-teksteditoren er aldeles forferdelig så jeg tror jeg stopper her!
Håper dette var nyttig-om det er noen spørsmål om I/O-systemet eller andre ting med Windows så er det bare å spørre.


mandag 27. oktober 2008

Grunnleggende info om feilsøking med Windbg.

Windbg er da det mest brukte verktøyet jeg bruker for å feilsøke problemer i Windows, enten det gjelder programmer som får uventede avsluttinger,system som kræsjer eller henger seg,mistanke om defekt maskinvare-Windbg kan brukes til å feilsøke alle disse problemene.

Windbg er en del av Debugging Tools For Windows som kan lastes ned gratis fra denne siden:
http://www.microsoft.com/whdc/devtools/debugging/default.mspx

Windbg kan både brukes til å feilsøke i User Mode og i Kernel Mode delen av systemet. Og har en rekke utvidelser som kan brukes for å gi ekstra informasjon så i hovedsak kan man bruke det til å finne ut absolutt alt som kan være nødvendig for å løse problemet. Dog kan det være vanskelig i starten å få overblikk over alle funksjonene, så jeg skal prøve her å gi en rask innføring av feilsøking med Windgb. Det er 3 hovedgrupper man kan dele feilsøkingen med Windbg inn i:

1.Feilsøking av Windows Programmer.
Du kan enten starte programmet via Ctrl+E og kjøre det via Windbg eller trykke F6 for å hekte Windbg på en allerede kjørende prosess. Dette vil da gjøres i et såkalt "Invasive" modus noe som betyr at du får fullstendig kontroll over programmet men som også betyr at Windbg vil kunne forstyrre normal programoppførsel og også at når du stopper feilsøkingen vil også prosessen avsluttes.
Du har også mulighet for å feilsøke det i "Non-invasive" modus som gir deg litt mindre kontroll men vil minske forstyrellsen Windbg har på prosessen.

2.Feilsøking av Kræsj-dumper.
En kræsjdump er rett og slett et sammendrag av tilstanden til minnet idet noe kræsjet og som har blitt dumpet ut til en fil på harddisken. Windbg kan feilsøke både kræsjdumper tatt fra prosesser eller kræsjdumper fra operativsystemet. Typisk kan du konfiguere hvor mye informasjon du vil ta med- du kan velge mellom en Minidump-som bare dumper ut de mest nødvendige strukturene som kan ha med kræsjet å gjøre, En Kjernedump som dumper ut hele Kjerneminnet eller en fullstendig minnedump som dumper ut absolutt hele minnet.

3.Feilsøking av kjernen.
Dette gjøres ved at debuggeren aktiveres i oppstarten av den maskinen man vil feilsøke, (Kan gjøres i feks Msconfig) og deretter kobler en kabel mellom maskinen som skal feilsøkes og datamaskinen som kjører Windbg. (Enten serie.firewire eller USB 2.0) Deretter kan man koble til maskinen og vente til den går på en feil eller stoppe systemet direkte. Man kan også gjøre såkalt lokal kjernefeilsøking men dette fungerer som regel ikke så godt og gir som regel rimelig begrenset informasjon. Angående kablene som brukes kreves det spesielle debugger-kabler for feilsøking via serie og USB 2.0 tilknyttning mens firewire kan bruke regulære kabler. USB 2.0 debugging støttes bare av Vista og nyere.

Symbolfiler
Før man kan begynne å feilsøke med Windbg er det viktig å oppgi en bane til Symbolfilene. Symbolfiler lages av linkeren som lager .exe eller .dll filer men legges ofte ikke ved siden disse ikke er nødvendig får å kunne kjøre disse filene. Dog er det veldig nyttig å ha symbolfilene når man skal feilsøke da disse kan inneholde nyttig data slik som:
  • Globale Variabler
  • Lokale Variabler
  • Navn på funksjoner
  • FPO opptegnelser

Microsoft legger heldigvis ut alle symbolfilene til sine moduler gratis på en symbolserver slik at du fritt laste ned symbolfilene ved behov. Disse inneholder dog bare funksjonnavn og spesifikke globale variabler men er allikavel ekstremt nyttig å konfigurere. Du kan enten konfiguere Symbolbanen ved .sympath kommandoen eller ved å trykke CTRL+S i Windbg. Banen til Microsoft sin symbolserver er: srv*"Symbolbane"*http://msdl.microsoft.com/downloads/symbols hvor "Symbolbane" er banen hvor symbolene blir lastet ned til lokalt til din maskin. Deretter skal symbolene bli lastet inn ved behov straks du kjører .reload. Om du har problemer med å få symbolene til å laste seg inn ordentlig kan du prøve å bruke !sym noisy kommandoen for å undersøke hvordan symbolene lastes.

Husk forøvrig på at en minidump fil ikke inneholder all informasjon om de kjørbare image filene til systemet og det kan være fordelaktig å legge inn banen til microsofts symbolserver også der slik at den kan laste ned image filene automatisk ved behov. Image banen settes ved å trykke CTRL+I eller skrive bruke .exepath kommandoen.




søndag 26. oktober 2008

Oversetting fra virtuell til fysisk adresse på et Windows xp x86 system.

De fleste operativsystem idag kjører med 32-bits addressering, noe som betyr at prosessoren kan adressere opp til 4gb virtuellt minne. Dette betyr ikke nødvendigvis at de kan adressere 4gb fysisk minne men la oss idag se på hvordan en 32 bits virituell addresse er bygd opp og hvordan disse igjen blir oversatt til en fysisk adresse.

En 32-bits addresse er delt inn i 3 hoveddeler de 10 første bitene benyttes til noe som kalles Page Directory Index som brukes til å finne den rette sidevekslings tabellen som inneholder PTE'en som tilhører den virituelle addressen. PTE står for Page Table Entry som er den strukturen som inneholder den fysiske addressen som den virituelle er mappet til.
Deretter består de neste 10 bitene av addressen av en struktur som kalles Page Table Index som har en peker til selve PTE'en i den aktuelle sidevekslingstabellen.
Tilslutt har man altså 12 gjenstående bit'er som er da avsatt til Byte Index som peker til den aktuelle addressen innenfor den fysiske siden.

Måten Windows leter frem til den fysiske adressen er slik at først letes prosessens Page Directory frem. Noe som skjer hvergang prosessoren gjør et context switch, og lagres typisk i et spesielt prosessor-register. (CR3 på X86) Deretter vil pekeren i Page Directory Index (10 første biter av addressen) vise til hvor den kan finne Page Directory Entry (PDE) som da igjen peker til det aktuelle sidevekslingstabellen. PDE er da en struktur som inneholder et såkalt Page Frame Number (PFN) som skal samsvare med det i sidevekslingstabellen.

Videre brukes da pekeren i Page Table Index (Neste 10 biter) som viser til lokaksjonen til den aktuelle PTE oppføringen. Deretter vil PTE brukes for å finne den fysiske addressen. Hvis PTE'en er gyldig vil den inneholde PFN'en til siden i det fysiske minnet som refererer til den virituelle addressen.

Hvis PTE'en peker til en gyldig side vil da Byte Index (Siste 12 biter) brukes for å finne ut hvor i den aktuelle siden dataen som skal hentes er.

For å forstå litt bedre hvordan denne prosessen fungerer kan det være greit å gå gjennom trinnene manuelt med en kjerne-debugger.


Vi tar da først utgangspunkt i prosessen msnmsgr.exe:

0: kd> !process
PROCESS 89f61270 SessionId: 0 Cid: 0d78 Peb: 7ffdb000 ParentCid: 03e4
DirBase: 0a960460 ObjectTable: e3fbe628 HandleCount: 866.
Image: msnmsgr.exe

Vi ser at Dirbase peker mot den fysiske addressen til Page Directoryen, som vi vet skal operativsystemet installere CR3 registeret med denne addressen slik at prosessoren vet hvor den skal finne Page Directory, la oss dumpe ut CR3 registeret for å sjekke at dette stemmer:

0: kd> r cr3
cr3=0a960460

La oss da ta utgangspunkt i den virtuelle addressen til et Hendeles-objekt i msnmsgr som har addresse 89809a30.
Konvert til bit blir det til 1000100110 0000001001 101000110000 og som vi vet skal de 10 første bitene er Page Directory Index som peker til den spesifikke PDE som har addressen til den spesifikke sidevekslingstabellen.
Page Directoryen ligger da altså på 0a960460 og vi har en Page Directory Index på 226 noe som igjen betyr at PDE ligger på fysisk addresse 0a960686

Vi kan da videre kalkulere oss frem til riktig PTE ved denne formelen:
Sidevekslingstabellbase (0XC0000000 på standard x86 systemer uten PAE)
+ Page Directory Index*størrelsen på en side(4kb på et x86 system)
+ Page Table Index*størrelsen på en PTE (4bytes på et x86 system)
= PTE

La oss kalkulere oss frem til addressen til PTE med denne formelen.
0XC0000000
+ 0X0044C000 (0X226*0X1000*2)
+ 0X00000048 (0X9*4*2)
= 0XC044C048

Som du ser har jeg i tillegg multiplisert resultatene med to, dette er fordi systemet har 2 prosessorer.
Vi kan sjekke om vi har funnet korrekt PTE ved å bruke !pte utvidelesen med en virtuell adresse:

0: kd> !pte 89809a10
VA 89809a10
PDE at 00000000C0602260 PTE at 00000000C044C048
contains 0000000009687963 contains 0000000008A51963
pfn 9687 -G-DA--KWEV pfn 8a51 -G-DA--KWEV

Vi kan videre dumpe ut innholdet av PTE'en: (Fremdeles 4 byte)

0: kd> dd 0C044C048 l1
c044c048 08a51963

PTEen inneholder to strukturer-de første 20 bitene er PFN mens de resterende 12 er avsatt til status flagg. For å finne den fysiske siden i minnet multipliserer vi PFN med størrelsen av en side (fremdeles 4kb) noe som gir oss adressen 08A51000. Dette er da bare basen på siden den fysiske siden. For å finne den eksakte adressen til hvor dataen ligger lagret bruker vi bare Byte indexen i den virtuelle adressen og adderer den med basen på den fysiske siden, noe som da gjør at vi ender opp med den fysiske adressen 08A51A30. La oss dumpe ut dataen som ligger her:

0: kd> !dc 8A51A30
# 8a51a30 aa044a01 00000000 8a288120 8a288120
# 8a51a40 0a060006 20646156 00003750 0000375f
# 8a51a50 89c27188 8979cbc0 8979c590 07100001
# 8a51a60 8a06dcc0 e1b97438 fffffffc 40000000
# 8a51a70 00020006 20646156 8a1169d0 89b30a18
# 8a51a80 0a060002 20646156 00000130 00000132
# 8a51a90 8a2cdc50 00000000 00000000 01400000
# 8a51aa0 8a126c58 e10b5d98 e10b5da8 41000000

La oss sammenligne dette med dataen i den virtuelle adressen:

0: kd> dc 89809a30
89809a30 aa044a01 00000000 8a288120 8a288120
89809a40 0a060006 20646156 00003750 0000375f
89809a50 89c27188 8979cbc0 8979c590 07100001
89809a60 8a06dcc0 e1b97438 fffffffc 40000000
89809a70 00020006 20646156 8a1169d0 89b30a18
89809a80 0a060002 20646156 00000130 00000132
89809a90 8a2cdc50 00000000 00000000 01400000
89809aa0 8a126c58 e10b5d98 e10b5da8 41000000

Vi ser da at dataen er identisk, vi kan med andre ord konkludere med at vi har lykkes i å konvertere en virtuell adresse til en fysisk adresse i minnet. Håper dette var nyttig for å forstå hvordan Windows konverterer minne!







fredag 24. oktober 2008

Windows Xp-maskin med bugcheck 0xA (IRQL not less or equal)

Windows maskinen ville gi blåskjerm hver gang bruker logget seg på-bestandig samme type bugcheck og parametre hver gang.
Hentet ut kjerneminnedump fra maskinen og åpnet den i Windbg og dumpet deretter ut stakken:

kd> kv
ChildEBP RetAddr Args to Child
f8959e08 804dbda3 badb0d00 00000000 82266008 nt!KiTrap0E+0x233 (FPO: [0,0] TrapFrame @ f8959e08)
f8959e98 804dc4a8 f8959fc0 0000003e f8959fc0 nt!KiWaitTest+0x30 (FPO: [Non-Fpo])
f8959fa4 804dc378 18d1bda0 00000000 ffdff000 nt!KiTimerListExpire+0x7a (FPO: [Non-Fpo])
f8959fd0 804dbbd4 8055a020 00000000 0000103d nt!KiTimerExpiration+0xaf (FPO: [Non-Fpo])
f8959ff4 804db89e baeead54 00000000 00000000 nt!KiRetireDpcList+0x46 (FPO: [0,0,0])
f8959ff8 baeead54 00000000 00000000 00000000 nt!KiDispatchInterrupt+0x2a (FPO: [Uses EBP] [0,0,1])
WARNING: Frame IP not in any known module. Following frames may be wrong.804db89e 00000000 00000009 bb835675 00000128 0xbaeead54

Nederste stakkramme ser ut til å være ugyldig og referer ikke til noen gyldig instruksjon-men for nå skal vi se på hva som egentlig trigget blåskjermen. Vi ser at feilen er fanget av KiTrap ved f8959e08 la oss endre kontekst ved å sette først .trap f8959e08 og deretter dumpe ut registrene:

kd> .trap f8959e08
ErrCode = 00000000
eax=00000000 ebx=81fd9fe8 ecx=f8959e88 edx=00000000 esi=81fd9fe0 edi=81fda008 eip=804dbda3 esp=f8959e7c ebp=f8959e98 iopl=0 nv up ei pl nz ac pe cycs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00010217
nt!KiWaitTest+0x30:804dbda3 6683781601 cmp word ptr [eax+16h],1 ds:0023:00000016=????

Vi kan av dette se at instruksen som feilet var en cmp (compare) instruksjon som hentet en peker fra eax+16. Denne instruksen feiler da fordi at som vi ser er eax registeret nullet ut og dette igjen får oss da til å lese fra minneområde 00000016 som da er et område i minnet som er resverert nullpekere og dermed er et ugyldig område i minnet. Første spørsmål vi har er hva som gjorde at eax ble satt til 0? Vi tar derfor en nærmere titt på instruksjone som ble kjørt innunder KiWaitTest.

kd> uf nt!KiWaitTest+0x30
nt!KiWaitTest:
804dbd7b 8bff mov edi,edi
804dbd7d 55 push ebp
804dbd7e 8bec mov ebp,esp
804dbd80 83ec10 sub esp,10h
804dbd83 53 push ebx
804dbd84 56 push esi
804dbd85 8bf1 mov esi,ecx
804dbd87 837e0400 cmp dword ptr [esi+4],0
804dbd8b 8d4df0 lea ecx,[ebp-10h]
804dbd8e 8d5e08 lea ebx,[esi+8]
804dbd91 8b03 mov eax,dword ptr [ebx]
804dbd93 8955f8 mov dword ptr [ebp-8],edx
804dbd96 894df4 mov dword ptr [ebp-0Ch],ecx
804dbd99 894df0 mov dword ptr [ebp-10h],ecx
804dbd9c 7e5f jle nt!KiWaitTest+0xd7 (804dbdfd)

nt!KiWaitTest+0x27:

804dbd9e 57 push edi

nt!KiWaitTest+0x28:
804dbd9f 3bc3 cmp eax,ebx
804dbda1 744f je nt!KiWaitTest+0xb7 (804dbdf2)

nt!KiWaitTest+0x30:
804dbda3 6683781601 cmp word ptr [eax+16h],1

Vi kan se dermed se at eax registeret blir satt ved instruksjonen:
804dbd91 8b03 mov eax,dword ptr [ebx]

Som henter en dword peker lagret i registeret ebx-hva ligger lagret i ebx?

kd> dd ebx
81fd9fe8 00000000 00000000 18d1af90 00000000
81fd9ff8 f8959fc0 f8959fc0 81fda008 00000000
81fda008 01000013 00000000 00000000 f8370f1a
81fda018 81fd9fe0 00000000 00000000 00000000
81fda028 bad67b5a 81fd7000 820e5ad0 00000000
81fda038 000a0008 00000001 81fda040 81fda040
81fda048 00000000 00000000 00000000 00000000
81fda058 81fda060 00000000 01000013 ffdff980

Som vi kan se er pekerne nullet ut og det er altså slik eax registret har blitt nullet ut.
Jeg slo på pool tagging med gflags for å forsøke å finne ut hvem som eide dette området av minnet og derettet kjøre
!pool opp mot denne addressen.

kd> !pool 81fd9fe8
Pool page 81fd9fe8 region is Nonpaged pool
*81fd7000 : large page allocation, Tag is NALW, size is 0x5000 bytes
Owning component : Unknown (update pooltag.txt)

Som vi kan se har modulen som har allokert dette minneområdet en ukjent minnetag "NALW" og vi kan derfor anta at dette tilhører en tredjepartsmodul. Hvordan finner vi ut hvilken driver som bruker denne tag'en?
Det enkleste er da å bruke programmet strings om kan lastes ned herfra:
http://technet.microsoft.com/en-us/sysinternals/bb897439.aspx

Deretter startet jeg det og kjøte det opp mot den vanligste lokasjonen for systemdrivere (c:\windows\system32\drivers)

Slik så resultatet ut:



Kom da frem til at pool-taggen tilhørte wlcom51b.sys. Som Windows beskrev som en miniport driver for wlan-kortet.

kd> lm kv m wlcom51b
start end module name
bad5e000 bad8ac00 wlcom51b (deferred)
Image path: \SystemRoot\system32\DRIVERS\wlcom51b.sys
Image name: wlcom51b.sys
Timestamp: Fri Oct 22 15:59:55 2004 (4179125B)
CheckSum: 00033C12
ImageSize: 0002CC00
Translations: 0000.04b0 0000.04e0 0409.04b0 0409.04e0

Ved oppdatering av denne forsvant problemet, så det ser ut til at det er denne driveren som har gjort stakken korrupt og skrevet over registeret ebx (som lå på stakken.)