Diese Seite ist unverschlüsselt! Um sicherzustellen, das Ihr Passwort nicht ausgelesen werden kann, sollten Sie auf die verschlüsselte Seite wechseln!

    Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » Assembler » Registerinhalte abspeichern
Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
03.11.2006, 13:55 Uhr
divB



 Hallo noch einmal!

Ich habe folgende Struktur:


C++:
typedef struct ArchThreadInfo
{
  uint32  eip;       // 0        INSTRUCTION REGISTER
  uint32  cs;        // 4        CodeSegment (Wo befindet sich der Code)
  uint32  eflags;    // 8        Statusregister
  uint32  eax;       // 12        Akkumulator, Arithmetik
  uint32  ecx;       // 16        Count-Register
  uint32  edx;       // 20        Datenregister (in/out, Arithmetik)
  uint32  ebx;       // 24        BaseRegister, g.p.
  uint32  esp;       // 28        Stackpointer, aktuelle Position im Stack; Ruecksprungadressen
  uint32  ebp;       // 32        BasePointer, Zeiger fuer Speicherstellen im Stack
  uint32  esi;       // 36        Source Index, Quelle bei str*
  uint32  edi;       // 40        Source Destination, Ziel bei str*
  uint32  ds;        // 44        DataSegment, Heap
  uint32  es;        // 48        ExtraSegment, weiteres Datensegment
  uint32  fs;        // 52        --''--
  uint32  gs;        // 56        --''--
  uint32  ss;        // 60        Stacksegment
  uint32  dpl;       // 64
  uint32  esp0;      // 68
  uint32  ss0;       // 72
  uint32  cr3;       // 76        ControlRegister 3, Pagetabelle
  uint32  fpu[27];   // 80
};


Diese möchte ich nun gerne mittels Inlineassembler mit den *aktuellen* Registerwerten füllen.

Allerdings ist mir nicht ganz klar wie ich das richtig mache.

Ist das hier korrekt?


C++:
__asm__ __volatile__("
mov %0, %%eip
mov %1, %%cs
mov %2, %%eax
[...]
"
:"=a"(dst->eip), "=a"(dst->cs), "=a"(dst->eax) [...]
:)


Aber wie kopiere ich z.B. das Flagregister (eflags) und den Zustand der FPU usw usw?

Das Problem ist, dass ich da nicht allzuviel herumprobieren kann, weil sich da ja leicht ein Fehler einschleichen kann, den ich auf Anhieb nicht bemerke (es geht um ein Betriebssystem)

Für ein Codeschnipsel oder jegliche Hilfe wäre ich sehr dankbar!

Vielen Dank im Vorraus,
divB
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
03.11.2006, 15:00 Uhr
ao

(Operator)


Falsches Forum

ao
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
03.11.2006, 15:06 Uhr
Th



 Dazu mußt du schon genau die Assemblerbefehle kennen, d.h. welche Seiteneffekte die einzelnen Befehle haben.
Den aktuellen Zustand des Statusregisters z.B. solltest du als erstes sichern und umgekehrt als letztes wieder setzen.

So genau kenne ich mich leider nicht mit den Intel/AMD-Prozessoren aus, aber beim Motorola gab es einen speziellen Superuser-Mode, bei dem erweiterte Befehle zur Verfügung standen, evtl. gibt es dies auch bei den Intel-Prozessoren.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
03.11.2006, 15:06 Uhr
divB



 Oh, entschuldigung, hab' das Assemblerforum ganz vergessen!

Achja, BTW: Es handelt sich natürlich um i386 und gcc.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
03.11.2006, 15:15 Uhr
divB



 Hmm schade.
Das Problem ist ja, dass ich mich da auch nicht so wirklich gut auskenne.

Ich habe eine Funktion gefunden die danach aussieht das zu machen


Code:
global arch_saveThreadRegisters
arch_saveThreadRegisters:
;        mov eax, dword[currentThreadInfo]
;        mov ebx, dword[eax + 0 ]  ; ArchThreadInfo
        mov ebx, dword[currentThreadInfo]
        fnsave [ebx + 80]
        frstor [ebx + 80]
        mov eax, dword[esp + 48]  ; get cs
        and eax, 0x03             ; check cpl is 3
        cmp eax, 0x03
        je from_user
from_kernel:
        mov eax, dword [esp + 44]; save eip
        mov dword[ebx], eax
        mov eax, dword [esp + 48]; save cs
        mov dword[ebx + 4], eax
        mov eax, dword [esp + 52]; save eflags
        mov dword[ebx + 8], eax
        mov eax, dword [esp + 40]; save eax
        mov dword[ebx + 12], eax
        mov eax, dword [esp + 36]; save ecx
        mov dword[ebx + 16], eax
        mov eax, dword [esp + 32]; save edx
        mov dword[ebx + 20], eax
        mov eax, dword [esp + 28]; save ebx
        mov dword[ebx + 24], eax
        mov eax, dword [esp + 24]; save esp
        add eax, 0xc
        mov dword[ebx + 28], eax
        mov eax, dword [esp + 20]; save ebp
        mov dword[ebx + 32], eax
        mov eax, dword [esp + 16]; save esi
        mov dword[ebx + 36], eax
        mov eax, dword [esp + 12]; save edi
        mov dword[ebx + 40], eax
        mov eax, [esp + 8]      ; save ds
        mov dword[ebx + 44], eax
        mov eax, [esp + 4]      ; save es
        mov dword[ebx + 48], eax
        ret
from_user:
        mov eax, dword[esp + 60] ; save ss3
        mov dword[ebx + 60], eax
        mov eax, dword[esp + 56] ; save esp3
        mov dword[ebx + 28], eax
        mov eax, dword [esp + 44]; save eip
        mov dword[ebx], eax
        mov eax, dword [esp + 48]; save cs
        mov dword[ebx + 4], eax
        mov eax, dword [esp + 52]; save eflags
        mov dword[ebx + 8], eax
        mov eax, dword [esp + 40]; save eax
        mov dword[ebx + 12], eax
        mov eax, dword [esp + 36]; save ecx
        mov dword[ebx + 16], eax
        mov eax, dword [esp + 32]; save edx
        mov dword[ebx + 20], eax
        mov eax, dword [esp + 28]; save ebx
        mov dword[ebx + 24], eax
        mov eax, dword [esp + 20]; save ebp
        mov dword[ebx + 32], eax
        mov eax, dword [esp + 16]; save esi
        mov dword[ebx + 36], eax
        mov eax, dword [esp + 12]; save edi
        mov dword[ebx + 40], eax
        mov eax, [esp + 8]      ; save ds
        mov dword[ebx + 44], eax
        mov eax, [esp + 4]      ; save es
        mov dword[ebx + 48], eax
        

        
        
        ret


Allerdings check ich das nicht. Erstens wieso es from_user und from_kernel gibt und zweitens wieso die ganzen Register (offenbar) vom Stack kommen und nicht aus den Registern selbst.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ Assembler ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: