Esempi di debug AML
Ecco alcuni esempi che illustrano come iniziare a eseguire il debug AML.
Analisi di un computer congelato
Se il computer di destinazione ha bloccato e si sospetta che sia un problema ACPI, iniziare usando l'estensione !amli lc per visualizzare tutti i contesti attivi:
kd> !amli lc
*Ctxt=ffffffff8128d000, ThID=ffffffff81277880, Flgs=----R----, pbOp=ffffffff8124206c, Obj=\_SB.PCI0.ISA0.FDC0._CRS
Se non vengono visualizzati contesti, l'errore probabilmente non è correlato a ACPI.
Se sono visualizzati contesti, cercare quello contrassegnato con un asterisco. Questo è il contesto corrente (quello che viene eseguito dall'interprete al momento attuale).
In questo esempio il computer di destinazione esegue Windows in un processore a 32 bit. Pertanto tutti gli indirizzi vengono gettato su 64 bit, generando un FFFFFFFFFF gratuito nei 32 bit elevati. Il pbOp abbreviazione indica il puntatore all'istruzione ("puntatore ai codici op binari"). Il campo Obj fornisce il percorso completo e il nome del metodo come viene visualizzato nelle tabelle ACPI. Per una descrizione dei flag, vedere !amli lc.
È possibile usare il comando !amli u per smontare il metodo _CRS come segue:
kd> !amli u \_SB.PCI0.ISA0.FDC0._CRS
ffffffff80e4a535 : CreateDWordFieldCRES, 0x76, RAMT)
ffffffff80e4a540 : CreateDWordField(CRES, 0x82, PCIT)
ffffffff80e4a54b : Add(MLEN(), 0x100000, RAMT)
ffffffff80e4a559 : Subtract(0xffe00000, RAMT, PCIT)
ffffffff80e4a567 : Return(CRES)
Interruzione nel debugger AMLI
Il comando del debugger !amli causa l'interruzione dell'interprete AML nel debugger AMLI alla successiva esecuzione di qualsiasi codice AML.
Dopo aver visualizzato il prompt del debugger AMLI, è possibile usare uno dei comandi del debugger AMLI. È anche possibile usare i comandi di estensione !amli senza prefissirli con "!amli":
kd> !amli debugger
kd> g
AMLI(? for help)-> find _crs
\_SB.LNKA._CRS
\_SB.LNKB._CRS
\_SB.LNKC._CRS
\_SB.LNKD._CRS
\_SB.PCI0._CRS
\_SB.PCI0.LPC.NCP._CRS
\_SB.PCI0.LPC.PIC._CRS
\_SB.PCI0.LPC.TIME._CRS
\_SB.PCI0.LPC.IDMA._CRS
\_SB.PCI0.LPC.RTC._CRS
\_SB.PCI0.LPC.SPKR._CRS
\_SB.PCI0.LPC.FHUB._CRS
\_SB.PCI0.SBD1._CRS
\_SB.PCI0.SBD2._CRS
\_SB.MBRD._CRS
AMLI(? for help)-> u \_SB.PCI0._CRS
ffffffff80e4a535 : CreateDWordFieldCRES, 0x76, RAMT)
ffffffff80e4a540 : CreateDWordField(CRES, 0x82, PCIT)
ffffffff80e4a54b : Add(MLEN(), 0x100000, RAMT)
ffffffff80e4a559 : Subtract(0xffe00000, RAMT, PCIT)
ffffffff80e4a567 : Return(CRES)
Uso dei punti di interruzione
Nell'esempio seguente si eseguirà l'interruzione nel debugger AMLI prima dell'esecuzione del metodo _BST.
Anche se si trova un oggetto _BST, è necessario verificare che sia effettivamente un metodo. È possibile usare l'estensione dns !amli per eseguire questa operazione.
kd> !amli dns /s \_sb.pci0.isa.bat1._bst
ACPI Name Space: \_SB.PCI0.ISA.BAT1._BST (c29c2044)
Method(_BST:Flags=0x0,CodeBuff=c29c20a5,Len=103)
A questo punto è possibile usare il comando !amli bp per posizionare il punto di interruzione:
kd> !amli bp \_sb.pci0.isa.bat1._bst
È anche possibile inserire punti di interruzione all'interno del metodo. È possibile usare il comando !amli u per disassemblare _BST e quindi posizionare un punto di interruzione in uno dei passaggi seguenti:
kd> !amli u _sb.pci0.isa.bat1._bst
ffffffffc29c20a5: Acquire(\_SB_.PCI0.ISA_.EC0_.MUT1, 0xffff)
ffffffffc29c20c0: Store("CMBatt - _BST.BAT1", Debug)
ffffffffc29c20d7: \_SB_.PCI0.ISA_.EC0_.CPOL()
ffffffffc29c20ee: Release(\_SB_.PCI0.ISA_.EC0_.MUT1)
ffffffffc29c2107: Return(PBST)
kd> !amli bp c29c20ee
Risposta a un punto di interruzione attivato
Nell'esempio seguente il metodo _WAK è in esecuzione e quindi rileva un punto di interruzione:
Running \_WAK method
Hit Breakpoint 0.
Usare l'estensione !amli ln per visualizzare il metodo più vicino al contatore del programma corrente. L'esempio seguente mostra gli indirizzi in formato a 32 bit:
kd> !amli ln
c29accf5: \_WAK
L'estensione !amli lc visualizza tutti i contesti attivi:
kd> !amli lc
Ctxt=c18b6000, ThID=00000000, Flgs=A-QC-W----, pbOp=c29bf8fe, Obj=\_SB.PCI0.ISA.EC0._Q09
*Ctxt=c18b4000, ThID=c15a6618, Flgs=----R-----, pbOp=c29accf5, Obj=\_WAK
Ciò indica che i contesti attivi sono associati ai metodi _Q09 e _WAK. Il contesto corrente è _WAK.
È ora possibile usare il comando !amli r per visualizzare altri dettagli sul contesto corrente. In questo modo è possibile visualizzare informazioni utili su thread e stack, nonché argomenti passati a _WAK e agli oggetti dati locali.
kd> !amli r
Context=c18b4000*, Queue=00000000, ResList=00000000
ThreadID=c15a6618, Flags=00000010
StackTop=c18b5eec, UsedStackSize=276 bytes, FreeStackSize=7636 bytes
LocalHeap=c18b40c0, CurrentHeap=c18b40c0, UsedHeapSize=88 bytes
Object=\_WAK, Scope=\_WAK, ObjectOwner=c18b4108, SyncLevel=0
AsyncCallBack=ff06b5d0, CallBackData=0, CallBackContext=c99efddc
MethodObject=\_WAK
c18b40e4: Arg0=Integer(:Value=0x00000001[1])
c18b5f3c: Local0=Unknown()
c18b5f54: Local1=Unknown()
c18b5f6c: Local2=Unknown()
c18b5f84: Local3=Unknown()
c18b5f9c: Local4=Unknown()
c18b5fb4: Local5=Unknown()
c18b5fcc: Local6=Unknown()
c18b5fe4: Local7=Unknown()
c18b4040: RetObj=Unknown()
Traccia, esecuzione e esecuzione di codice AML
Se si vuole tracciare il codice, è possibile attivare le informazioni di traccia completa usando l'estensione !amli set come indicato di seguito:
kd> !amli set spewon verboseon traceon
A questo punto è possibile eseguire il codice AML, osservando la riga di esecuzione del codice in base alla riga. Il comando p esegue la procedura per tutte le chiamate di funzione. Il comando t eseguirà le chiamate di funzione.
AMLI(? for help)-> p
c29bfcb7: Store(\_SB_.PCI0.ISA_.ACAD.CHAC(SEL0=0x10e1)
c29c17b1: {
c29c17b1: | Store(LGreater(And(Arg0=0x10e1,0xf0,)=0xe0,0x80)=0xffffffff,Local0)=0xffffffff
AMLI(? for help)-> p
c29c17bb: | If(LNot(LEqual(Local0=0xffffffff,ACP_=0xffffffff)=0xffffffff)=0x0)
c29c17ce: | {
c29c17ce: | | Return(Zero)
c29c17d0: | }
c29c17d0: },Local1)=0x0
AMLI(? for help)-> t
c29bfcd4: Store(\_SB_.PCI0.ISA_.BAT1.CHBP(SEL0=0x10e1)
c29c293d: {
c29c293d: | Store("CMBatt - CHBP.BAT1",Debug)String(:Str="CMBatt - CHBP.BAT1")="CMBatt - CHBP.BAT1"
È anche possibile eseguire metodi dall'interno del debugger AMLI se si sceglie. Ad esempio, è possibile valutare lo stato del dispositivo LNKA eseguendo il metodo di controllo _STA:
AMLI(? for help)-> run \_sb.lnka._sta
PCI OpRegion Access on region c29b2268 device c29b2120
\_SB.LNKA._STA completed successfully with object data:
Integer(:Value=0x0000000b[11])
Vedere anche
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per