Interrupts

[Dirty Oerti]

Du vermutest die Sicherungsfunktion?
Kannst du diese Vermutung irgendwie begründen?

Wahrscheinlich liegt es dadrann, dass der Compiler deinen Inlineassembler automatisch Optimiert.
Das führt dazu, dass Register für Variablen verwendet werden => Die Register enthalten falsch Werte.

Es könnte auch sein, dass deine Sicherungsfunktion nicht richtig ist.

Was hast du eigntl gegen Assembler?
Ohne ist wirklich nicht gerade einfach.

[Xin]

Compilire das ganze, keine fehler. Mounte das Image mit VirtualPC, es startet und dann kommt die meldung: Unbehebarer Prozessorfehler.
Ich führe das auf die Register sicherungsfuktion zurück.
Also wie soll eine Funktion ausehen, die die Register in ein Struct speichert, und dann wieder herstellt mit hlife des Stucts???

Vielleicht wäre es einfacher, wenn Du Deine Funktionen postest?

[cloidnerux]

Code: Alles auswählen

void save_registers() //speichert die regsiter
{
	asm("mov %0, %%ax": "=ra" (registers.ax) :);
	asm("mov %0, %%bx": "=ra" (registers.bx) :);
	asm("mov %0, %%cx": "=ra" (registers.cx) :);
	asm("mov %0, %%dx": "=ra" (registers.dx) :);
	asm("mov %0, %%cs": "=ra" (registers.cs) :);
	asm("mov %0, %%ds": "=ra" (registers.ds) :);
	asm("mov %0, %%ss": "=ra" (registers.ss) :);
	asm("mov %0, %%es": "=ra" (registers.es) :);
	asm("mov %0, %%sp": "=ra" (registers.sp) :);
	asm("mov %0, %%bp": "=ra" (registers.bp) :);
	//asm("mov %0, %%ip": "=ra" (registers.ip) :);
	asm("mov %0, %%si": "=ra" (registers.si) :);
	asm("mov %0, %%di": "=ra" (registers.di) :);
}
/*diese funktion lädt die oben gespeicherten register,
um die vorherigen settings wieerherzustellen und den kernel
normal weiterlaufen zu lassen*/
void reload_registers()  //lädt die register neu
{
	asm("mov %%ax, %0": : "r" (registers.ax));
	asm("mov %%bx, %0": : "r" (registers.bx));
	asm("mov %%cx, %0": : "r" (registers.cx));
	asm("mov %%dx, %0": : "r" (registers.dx));
	asm("mov %%cs, %0": : "r" (registers.cs));
	asm("mov %%ds, %0": : "r" (registers.ds));
	asm("mov %%ss, %0": : "r" (registers.ss));
	asm("mov %%es, %0": : "r" (registers.es));
	asm("mov %%sp, %0": : "r" (registers.sp));
	asm("mov %%bp, %0": : "r" (registers.bp));
	//asm("mov %%ip, %0": : (registers.ip));
	asm("mov %%si, %0": : "r" (registers.si));
	asm("mov %%di, %0": : "r" (registers.di));
}

Das sind die Funktionen. Registers.XY bezieht sich auf ein struct:

Code: Alles auswählen

struct asm_register		//struct zum speichern der register benötigt von interrupting.h
{
	//Allgemine Register
	short int ax;
	short int bx;
	short int cx;
	short int dx;
	//Segmentregister
	short int cs;
	short int ds;
	short int ss;
	short int es;
	//Pointer Register
	short int sp;
	short int bp;
	short int ip;
	//index register
	short int si;
	short int di;
};

Wenn ich das OS starte, kommt: *Unbehebarer Prozessorfehler*
Also vermute ich das ich die Register nicht richtig zurücklade.
Das liegt entweder:
a: An meinen Schlechten Assemblerkenntnissen, oder
b: an den Optimirungsfunktionen von GCC

Was hast du eigntl gegen Assembler?

ICh habe nichts gegen Assembler, ich habe nur was gegen den Inline Assembler,
viele zu viele '%' und '&'. Ich komm gerade so mit der Intelstruktur zurecht.

[taljeth]

Also vermute ich das ich die Register nicht richtig zurücklade.
Das liegt entweder:
a: An meinen Schlechten Assemblerkenntnissen, oder
b: an den Optimirungsfunktionen von GCC

Ich nehme Antwort A, Herr Jauch.

Hast du dir mal überlegt, was für ein Code da am Ende wirklich rauskommt? Die Register sind doch alle längst überschrieben, bis du mal irgendwas sicherst... Davon abgesehen willst du auch nicht nur die unteren 16 Bit der Register speichern, sondern die vollen 32 Bit. Mach das irgendwie so (ich vergesse sicher wieder die Hälfte, aber das wesentliche ist, daß du den C-Compiler nicht reinpfuschen läßt, sondern direkt eine Assemblerdatei nimmst, die du dazulinkst):

Code: Alles auswählen

int_handler:
  push eax
  push ebx
  ...
  call c_int_handler
  ...
  pop ebx
  pop eax

  add esp, 4 ; Interruptnummer vom Stack nehmen (falls der Interrupt einen Error Code hat, 8 statt 4)
  iret

Abkürzend kannst du auch pusha/popa für einige Register (alle außer Segmentregister? Steht in der Intel-Doku.) nehmen.

[cloidnerux]

Was bewirkt 'push' und 'pop'. Schreiebn die nicht einfach was auf den Stack??
OK, werd das mal einbauen

[taljeth]

Genau. Und der Stack ist der perfekte Platz, um die Register hinzusichern.

[fat-lobyte]

Schon mal was von der Anweisung "pusha" und "pushad" gehört?
Vielleicht könnte euch die Interessieren:

http://pdos.csail.mit.edu/6.828/2004/re ... /PUSHA.htm

[cloidnerux]

und popa/poad holt sie wieder vom speicher, wenn ich das richtig sehe.
Danke.