Nachrichten

61

Lowlevel-Coding / Re: Multitasking in Ring-3

« am: 27. April 2012, 17:21 »

Mit meinem Wissen kann ich da nicht viel über den Sprung ins nichts herauslesen.
Das ist vielleicht was für die Experten

Code: [Auswählen]

SMM: enter
EAX=00000001 EBX=80000b58 ECX=00000000 EDX=00000cfc
ESI=000e5cbd EDI=0003802d EBP=00000cf8 ESP=00006f00
EIP=000e7a31 EFL=00000002 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
CS =0008 00000000 ffffffff 00cf9b00 DPL=0 CS32 [-RA]
SS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
DS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
FS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
GS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
LDT=0000 00000000 0000ffff 00008200 DPL=0 LDT
TR =0000 00000000 0000ffff 00008b00 DPL=0 TSS32-busy
GDT=     000fce38 00000037
IDT=     000fdcf0 00000000
CR0=00000011 CR2=00000000 CR3=00000000 CR4=00000000
DR0=00000000 DR1=00000000 DR2=00000000 DR3=00000000
DR6=ffff0ff0 DR7=00000400
CCS=000e5c90 CCD=00000001 CCO=LOGICB 
EFER=0000000000000000
SMM: after RSM
EAX=00000001 EBX=80000b58 ECX=00000000 EDX=00000cfc
ESI=000e5cbd EDI=0003802d EBP=00000cf8 ESP=00006f00
EIP=000e7a31 EFL=00000002 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0010 00000000 ffffffff 00c09300 DPL=0 DS   [-WA]
CS =0008 00000000 ffffffff 00c09b00 DPL=0 CS32 [-RA]
SS =0010 00000000 ffffffff 00c09300 DPL=0 DS   [-WA]
DS =0010 00000000 ffffffff 00c09300 DPL=0 DS   [-WA]
FS =0010 00000000 ffffffff 00c09300 DPL=0 DS   [-WA]
GS =0010 00000000 ffffffff 00c09300 DPL=0 DS   [-WA]
LDT=0000 00000000 0000ffff 00008200 DPL=0 LDT
TR =0000 00000000 0000ffff 00008b00 DPL=0 TSS32-busy
GDT=     000fce38 00000037
IDT=     000fdcf0 00000000
CR0=00000011 CR2=00000000 CR3=00000000 CR4=00000000
DR0=00000000 DR1=00000000 DR2=00000000 DR3=00000000
DR6=ffff0ff0 DR7=00000400
CCS=00000000 CCD=ffffff9c CCO=EFLAGS 
EFER=0000000000000000
     0: v=21 e=0000 i=0 cpl=0 IP=0008:001022fd pc=001022fd SP=0010:00107f40 EAX=000000ed
EAX=000000ed EBX=0002c100 ECX=00000410 EDX=00000060
ESI=0002c276 EDI=0002c27b EBP=00107f78 ESP=00107f40
EIP=001022fd EFL=00000202 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
CS =0008 00000000 ffffffff 00cf9a00 DPL=0 CS32 [-R-]
SS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
DS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
FS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
GS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
LDT=0000 00000000 0000ffff 00008200 DPL=0 LDT
TR =0028 001041a0 0000007f 0000e900 DPL=3 TSS32-avl
GDT=     0010c8c0 0000002f
IDT=     00108000 000007f7
CR0=00000011 CR2=00000000 CR3=00000000 CR4=00000000
DR0=00000000 DR1=00000000 DR2=00000000 DR3=00000000
DR6=ffff0ff0 DR7=00000400
CCS=00000008 CCD=00107f30 CCO=SUBL   
EFER=0000000000000000
     1: v=21 e=0000 i=0 cpl=0 IP=0008:00102091 pc=00102091 SP=0010:00107fb0 EAX=00000000
EAX=00000000 EBX=0002c100 ECX=00000410 EDX=00000060
ESI=0002c276 EDI=0002c27b EBP=00107fc8 ESP=00107fb0
EIP=00102091 EFL=00000202 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0023 00000000 ffffffff 00cff300 DPL=3 DS   [-WA]
CS =0008 00000000 ffffffff 00cf9a00 DPL=0 CS32 [-R-]
SS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
DS =0023 00000000 ffffffff 00cff300 DPL=3 DS   [-WA]
FS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
GS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
LDT=0000 00000000 0000ffff 00008200 DPL=0 LDT
TR =0028 001041a0 0000007f 0000e900 DPL=3 TSS32-avl
GDT=     0010c8c0 0000002f
IDT=     00108000 000007f7
CR0=00000011 CR2=00000000 CR3=00000000 CR4=00000000
DR0=00000000 DR1=00000000 DR2=00000000 DR3=00000000
DR6=ffff0ff0 DR7=00000400
CCS=00000008 CCD=00107fa0 CCO=SUBL   
EFER=0000000000000000
     2: v=21 e=0000 i=0 cpl=0 IP=0008:001022fd pc=001022fd SP=0010:00107f40 EAX=000000f3
EAX=000000f3 EBX=0002c100 ECX=00000410 EDX=00000060
ESI=0002c276 EDI=0002c27b EBP=00107f78 ESP=00107f40
EIP=001022fd EFL=00000202 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0023 00000000 ffffffff 00cff300 DPL=3 DS   [-WA]
CS =0008 00000000 ffffffff 00cf9a00 DPL=0 CS32 [-R-]
SS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
DS =0023 00000000 ffffffff 00cff300 DPL=3 DS   [-WA]
FS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
GS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
LDT=0000 00000000 0000ffff 00008200 DPL=0 LDT
TR =0028 001041a0 0000007f 0000e900 DPL=3 TSS32-avl
GDT=     0010c8c0 0000002f
IDT=     00108000 000007f7
CR0=00000011 CR2=00000000 CR3=00000000 CR4=00000000
DR0=00000000 DR1=00000000 DR2=00000000 DR3=00000000
DR6=ffff0ff0 DR7=00000400
CCS=00000008 CCD=00107f30 CCO=SUBL   
EFER=0000000000000000
     3: v=21 e=0000 i=0 cpl=0 IP=0008:001020b1 pc=001020b1 SP=0010:00107fb0 EAX=00000000
EAX=00000000 EBX=0002c100 ECX=00000410 EDX=00000060
ESI=0002c276 EDI=0002c27b EBP=00107fc8 ESP=00107fb0
EIP=001020b1 EFL=00000202 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0023 00000000 ffffffff 00cff300 DPL=3 DS   [-WA]
CS =0008 00000000 ffffffff 00cf9a00 DPL=0 CS32 [-R-]
SS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
DS =0023 00000000 ffffffff 00cff300 DPL=3 DS   [-WA]
FS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
GS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
LDT=0000 00000000 0000ffff 00008200 DPL=0 LDT
TR =0028 001041a0 0000007f 0000e900 DPL=3 TSS32-avl
GDT=     0010c8c0 0000002f
IDT=     00108000 000007f7
CR0=00000011 CR2=00000000 CR3=00000000 CR4=00000000
DR0=00000000 DR1=00000000 DR2=00000000 DR3=00000000
DR6=ffff0ff0 DR7=00000400
CCS=00000008 CCD=00107fa0 CCO=SUBL   
EFER=0000000000000000
     4: v=21 e=0000 i=0 cpl=0 IP=0008:001022fd pc=001022fd SP=0010:00107f40 EAX=000000f4
EAX=000000f4 EBX=0002c100 ECX=00000410 EDX=00000060
ESI=0002c276 EDI=0002c27b EBP=00107f78 ESP=00107f40
EIP=001022fd EFL=00000202 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0023 00000000 ffffffff 00cff300 DPL=3 DS   [-WA]
CS =0008 00000000 ffffffff 00cf9a00 DPL=0 CS32 [-R-]
SS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
DS =0023 00000000 ffffffff 00cff300 DPL=3 DS   [-WA]
FS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
GS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
LDT=0000 00000000 0000ffff 00008200 DPL=0 LDT
TR =0028 001041a0 0000007f 0000e900 DPL=3 TSS32-avl
GDT=     0010c8c0 0000002f
IDT=     00108000 000007f7
CR0=00000011 CR2=00000000 CR3=00000000 CR4=00000000
DR0=00000000 DR1=00000000 DR2=00000000 DR3=00000000
DR6=ffff0ff0 DR7=00000400
CCS=00000008 CCD=00107f30 CCO=SUBL   
EFER=0000000000000000
     5: v=20 e=0000 i=0 cpl=0 IP=0008:001019cf pc=001019cf SP=0010:00107f90 EAX=00000001
EAX=00000001 EBX=0002c100 ECX=000006e0 EDX=000003d5
ESI=0002c276 EDI=0002c27b EBP=00107fc8 ESP=00107f90
EIP=001019cf EFL=00000202 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0023 00000000 ffffffff 00cff300 DPL=3 DS   [-WA]
CS =0008 00000000 ffffffff 00cf9a00 DPL=0 CS32 [-R-]
SS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
DS =0023 00000000 ffffffff 00cff300 DPL=3 DS   [-WA]
FS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
GS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
LDT=0000 00000000 0000ffff 00008200 DPL=0 LDT
TR =0028 001041a0 0000007f 0000e900 DPL=3 TSS32-avl
GDT=     0010c8c0 0000002f
IDT=     00108000 000007f7
CR0=00000011 CR2=00000000 CR3=00000000 CR4=00000000
DR0=00000000 DR1=00000000 DR2=00000000 DR3=00000000
DR6=ffff0ff0 DR7=00000400
CCS=00000004 CCD=0010caa0 CCO=EFLAGS 
EFER=0000000000000000
     6: v=20 e=0000 i=0 cpl=3 IP=001b:001013ba pc=001013ba SP=0023:0010b814 EAX=00000372
EAX=00000372 EBX=00000371 ECX=000b8000 EDX=000b8371
ESI=00000000 EDI=00000000 EBP=0010b84c ESP=0010b814
EIP=001013ba EFL=00000202 [-------] CPL=3 II=0 A20=1 SMM=0 HLT=0
ES =0023 00000000 ffffffff 00cff300 DPL=3 DS   [-WA]
CS =001b 00000000 ffffffff 00cffa00 DPL=3 CS32 [-R-]
SS =0023 00000000 ffffffff 00cff300 DPL=3 DS   [-WA]
DS =0023 00000000 ffffffff 00cff300 DPL=3 DS   [-WA]
FS =0000 00000000 00000000 00000000
GS =0000 00000000 00000000 00000000
LDT=0000 00000000 0000ffff 00008200 DPL=0 LDT
TR =0028 001041a0 0000007f 0000e900 DPL=3 TSS32-avl
GDT=     0010c8c0 0000002f
IDT=     00108000 000007f7
CR0=00000011 CR2=00000000 CR3=00000000 CR4=00000000
DR0=00000000 DR1=00000000 DR2=00000000 DR3=00000000
DR6=ffff0ff0 DR7=00000400
CCS=00000085 CCD=fffff472 CCO=EFLAGS 
EFER=0000000000000000
qemu: fatal: Trying to execute code outside RAM or ROM at 0x665b6620

EAX=00000010 EBX=00000371 ECX=000b8000 EDX=000b8371
ESI=00000000 EDI=00000000 EBP=0010b84c ESP=ffffffc0
EIP=665b6620 EFL=00000002 [-------] CPL=0 II=0 A20=1 SMM=0 HLT=0
ES =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
CS =0008 00000000 ffffffff 00cf9a00 DPL=0 CS32 [-R-]
SS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
DS =0010 00000000 ffffffff 00cf9300 DPL=0 DS   [-WA]
FS =0000 00000000 00000000 00000000
GS =0000 00000000 00000000 00000000
LDT=0000 00000000 0000ffff 00008200 DPL=0 LDT
TR =0028 001041a0 0000007f 0000e900 DPL=3 TSS32-avl
GDT=     0010c8c0 0000002f
IDT=     00108000 000007f7
CR0=00000011 CR2=00000000 CR3=00000000 CR4=00000000
DR0=00000000 DR1=00000000 DR2=00000000 DR3=00000000
DR6=ffff0ff0 DR7=00000400
CCS=00000085 CCD=fffff472 CCO=EFLAGS 
EFER=0000000000000000
FCW=037f FSW=0000 [ST=0] FTW=00 MXCSR=00001f80
FPR0=0000000000000000 0000 FPR1=0000000000000000 0000
FPR2=0000000000000000 0000 FPR3=0000000000000000 0000
FPR4=0000000000000000 0000 FPR5=0000000000000000 0000
FPR6=0000000000000000 0000 FPR7=0000000000000000 0000
XMM00=00000000000000000000000000000000 XMM01=00000000000000000000000000000000
XMM02=00000000000000000000000000000000 XMM03=00000000000000000000000000000000
XMM04=00000000000000000000000000000000 XMM05=00000000000000000000000000000000
XMM06=00000000000000000000000000000000 XMM07=00000000000000000000000000000000


62

Lowlevel-Coding / Re: Multitasking in Ring-3

« am: 22. April 2012, 17:17 »

So. Das Problem mit der GDT habe ich jetzt nicht mehr (die Flags müssen um 20 geschoben werden).   

Allerdings hab ich jetzt ein anders problem:
   Wenn ich mein Userspace-Codesegment auf ring-0 setze (das Segment für die Tasks) und in meinem init_task .cs auf 0x18 statt
   0x1b setzte funktioniert das Multitasking , aber nur in Ring-0.
   In Ring-3 geht das genze nicht: es kommt dann der Fehler von qemu: fatal: trying to execute code outside RAM or ROM at 0x...
   d.h. er springt irgendwo hin.

könnt ihr mir da helfen?

63

Lowlevel-Coding / Re: Multitasking in Ring-3

« am: 20. April 2012, 14:37 »

Also jetzt nochmal zur Zusammenfassung.

Mein Problem liegt jetzt in der GDT.
der Code:
gdt.c

Code: [Auswählen]

#include <stdint.h>
#include "gdt.h"

//Acessbyte
#define GDT_PRESENT 0x80
#define GDT_SEGMENT 0x10
#define GDT_RING0   0x00
#define GDT_RING3   0x60
#define GDT_CODESEG_NR 0x00
#define GDT_CODESEG_RD 0x0A
#define GDT_DATASEG_RD 0x00
#define GDT_DATASEG_WR 0x02
#define GDT_TSS        0x09

//Flags
#define GDT_4K_GRAN 0x08
#define GDT_32_BIT  0x04

/* ---------- Globale Variablen ----------------------- */
static uint64_t gdt[GDT_ENTRIES]; //Global Deskriptor Table
static uint32_t tss[TSS_SIZE] = {0, 0, 0x10}; //Task State Segment
/* ---------- Eintrag in die GDT setzen --------------- */
void set_gdt_entry(int i, uint32_t limit, uint32_t base, uint8_t access, uint8_t flags){
  gdt[i] = 0;
  //untere 32-Bit
  gdt[i] = (limit & 0x0ffff) | ((base & 0x0000ffff) << 16);
  //obere 32-Bit
  gdt[i] |=(
    ( (base & 0x00ff0000) >> 16 ) |
    ( access << 8 ) |
    ( flags << 16 ) |
    ( limit & 0xf0000 ) |
    ( base & 0xff000000 )
   ) * 0x100000000;
}
/* ---------- GDT Laden (GDTR ändern) ----------------- */
void load_gdt(void){
  struct {
    uint16_t size;
    uint64_t *pointer;
  } __attribute__((packed)) gdtp = {
    .size = GDT_ENTRIES * 8 - 1,
    .pointer = gdt,
  };
  asm volatile("lgdt %0" : : "m" (gdtp));//GDT Laden
}
/* ---------- GDT initalisieren ----------------------- */
void init_gdt(void){
 
  //Nulldeskriptor
    set_gdt_entry(GDT_ENTRY_NULL, 0, 0, 0, 0);

  //Kernel - Codesegment
    set_gdt_entry(GDT_ENTRY_KERNEL_CODE, 0xfffff, 0, //index, limit, base
GDT_CODESEG_RD | GDT_SEGMENT | GDT_RING0 | GDT_PRESENT,//Access-Byte
GDT_32_BIT  | GDT_4K_GRAN); //Flags
     
  //Kernel - Datensegment      
    set_gdt_entry(GDT_ENTRY_KERNEL_DATA, 0xfffff, 0, //index, limit, base
GDT_DATASEG_WR | GDT_SEGMENT | GDT_RING0 | GDT_PRESENT,//Access-Byte
GDT_32_BIT  | GDT_4K_GRAN);       //Flags
     
  //Userspace - Codesegment    
    set_gdt_entry(GDT_ENTRY_USER_CODE, 0xfffff, 0, //index, limit, base
GDT_CODESEG_RD | GDT_SEGMENT | GDT_RING3 | GDT_PRESENT,//Access-Byte
GDT_32_BIT  | GDT_4K_GRAN); //Flags
     
  //Userpsace - Datensegment      
    set_gdt_entry(GDT_ENTRY_USER_DATA, 0xfffff, 0, //index, limit, base
GDT_DATASEG_WR | GDT_SEGMENT | GDT_RING3 | GDT_PRESENT,//Access-Byte
         GDT_32_BIT  | GDT_4K_GRAN); //Flags
   
  //Task State Segment
    set_gdt_entry(GDT_ENTRY_TSS, sizeof(tss)-1, (uint32_t) &tss,//index, limit, base
GDT_TSS | GDT_PRESENT | GDT_RING3, //Access-Byte
0); //Flags

   // nach ss0 das Kernel Datensegment legen
    tss[2] = 0x10;
}
/* ---------- GDT schnell initalisieren --------------- */
void init_gdt_fast(void){
  gdt[0] = 0x0000000000000000;//Nulldeskriptor
  gdt[1] = 0x00FC9A000000FFFF;//Kernel - Codesegment
  gdt[2] = 0x00FC92000000FFFF;//Kernel - Datensegment
  gdt[3] = 0x00FCFA000000FFFF;//Userspace - Codesegment
  gdt[4] = 0x00FCF2000000FFFF;//Userpsace - Datensegment
  set_gdt_entry(5, sizeof(tss)-1, (uint32_t) &tss, //index, limit, base
GDT_TSS | GDT_PRESENT | GDT_RING3, //Access-Byte
0); //Flags

   // nach ss0 das Kernel Datensegment legen
    tss[2] = 0x10;
}

/* -------Ende gdt.c ------*/
Um unnötige Fragen zu vermeiden: Ich verwende nicht init_gdt_fast sondern init_gdt!!


Wo steckt jetzt mein Fehler, dass Qemu beim beladen der Segmentregister neustertet? ( relaod_segment_registers(void) )

Bzw. Warum startet Qemu nicht neu, wenn ich diese (falsche) Funktion verwende?:

Code: [Auswählen]

/* ---------- Eintrag in die GDT setzen --------------- */
void set_gdt_entry(int i, uint32_t limit, uint32_t base, uint8_t access, uint8_t flags){
  gdt[i] = 0;
  //untere 32-Bit
  gdt[i] = (limit & 0x0ffff) | ((base & 0x0000ffff) << 16);
  //obere 32-Bit
  gdt[i] |=(
    ( (base & 0x00ff0000) >> 16 ) |
    ( access << 8 ) |
    ( flags << 16 ) |
    ( (limit & 0xf0000) << 4) |
    ( base & 0xff000000 )
   ) * 0x100000000;
}
Micha

64

Softwareentwicklung / Re: Lowlevel Tutorial Problem

« am: 18. April 2012, 20:09 »

dort hast du ENTRY als "start" definiert. Wie sieht denn dein kernel32.asm aus?
Was hast du dir überhaupt mit kernel16.asm gedacht?

65

Softwareentwicklung / Re: Lowlevel Tutorial Problem

« am: 18. April 2012, 20:01 »

Wie setzt du den das ENTRY in deinem Linkerskript?
Vielleicht gleich das ganze link.txt

66

Softwareentwicklung / Re: Lowlevel Tutorial Problem

« am: 18. April 2012, 19:56 »

kommt nicht eigentlich bim Linker der Pfad zum Linkerskript gleich nach dem T, ohne Leerteichen?

67

Lowlevel-Coding / Re: Multitasking in Ring-3

« am: 18. April 2012, 14:26 »

keine Änderung 
qemu startet auch schon beim neuladen der Segmentregister neu

68

Lowlevel-Coding / Re: Multitasking in Ring-3

« am: 17. April 2012, 19:59 »

Also im Wiki-Artikel TSS steht da nix über die Flags in der GDT.
hab auch mal mit 0 in den Flags probiert: kein Unterschied

69

Lowlevel-Coding / Re: Multitasking in Ring-3

« am: 17. April 2012, 19:43 »

Nunja. Nur das wirds wohl nicht allein gewesen sein. Es gibt also auch noch andere Fehler.
Immerhin springt er jetzt nicht mehr irgendwo hin und versucht irgendeinen Quatsch auszuführen.....er startet neu.
Liegt das dann an dem TSS? Das sollte doch eigentlich stimmen.?

70

Lowlevel-Coding / Re: Multitasking in Ring-3

« am: 17. April 2012, 16:05 »

könnte es sein, dass sich jetzt der Fehler in der GDT bemerkbar macht?
Was mache ich da überhaupt für einen Fehler? (in set_gdt_entry)


LG micha

71

Lowlevel-Coding / Re: Problem mit Boot

« am: 17. April 2012, 14:38 »

Als editor? KWrite (kate)

Eigentlich von KDE. läuft bei mir auch unter GNOME

edit:
Aber ein IDE ist es eigentlich nicht

72

Lyrisches Eck / Re: ASM Alles System Mist

« am: 14. April 2012, 13:29 »

Alles
Selber
Machen

73

Das Wiki / Re: outb in Tutorials

« am: 13. April 2012, 14:01 »

Ich habs mal ohne -g probiert. Aber einsetzten tut er das outb nicht. die Funktionen outb/w/l gibt's immernoch und der macht mir ein call outb hin. liegt das on den Optimirungen? Wie schalte ich die an?

74

Lowlevel-Coding / Multitasking in Ring-3

« am: 12. April 2012, 19:55 »

Hi,

Nachdem ich jetzt das Multitasking in Ring 0 hinbekommen habe, wollte ich jetzt das genze nach ring 3 verschieben.
Nur leider kommen As bis zum nächsten Timerinterrupt und dann meldet qemu: fatal: trying to execute code outside RAM or ROM.(oder so ähnlich)

könnte da mal jemand drübergucken?

multitasking.c

Code: [Auswählen]

#include <stdint.h>
#include "gdt.h"
#include "interrupt.h"
#include "cpu.h"
#include "console.h"

/* ---------- Globale Variablen ----------------------- */
static uint8_t stack_a[4096];
static uint8_t stack_b[4096];
static uint8_t user_stack_a[4096];
static uint8_t user_stack_b[4096];

static int current_task = -1;
static int num_tasks = 2;
static cpu_state* task_states[2];
/* --------- Tasks ------------- */
void task_a(void){
  while(1){
    setColor(0x02);
    printf("A");
  }
}
void task_b(void){
  while(1){
    setColor(0x06);
    printf("B");
  }
}
/* ---------- Task initalisieren ---------------------- */
cpu_state* init_task(uint8_t *stack, uint8_t *user_stack, void *entry){
    cpu_state new_state = {
.eax = 0,
.ebx = 0,
.ecx = 0,
.edx = 0,
.esi = 0,
.edi = 0,
.ebp = 0,

        .esp = (uint32_t) user_stack + 4096,
.eip = (uint32_t) entry,

// Ring-3 Segmentregister
.cs = 0x1b /*0x18 | 0x03*/,
.ss = 0x23 /*0x20 | 0x03*/,

// IRQs einschalten
.eflags = 0x202,
    };
   
    cpu_state *state = (void*) (stack + 4096 - sizeof(new_state));
    *state = new_state;
   
    return state;
}
/* ---------- Multitasking initalisieren -------------- */
void init_multitasking(void){
    task_states[0] = init_task(stack_a, user_stack_a, task_a);
    task_states[1] = init_task(stack_b, user_stack_b, task_b);
    cpu_dump(task_states[0]);
    cpu_dump(task_states[1]);
}
/* ---------- Scheduler ------------------------------- */
cpu_state* schedule(cpu_state *cpu){
   
    // Alten zustand des Tasks sichern
    if(current_task >= 0){
task_states[current_task] = cpu;
    }
   
    // Nächsten Task auswählen
    current_task++;
    current_task %= num_tasks;
   
    // Neuen Task aktivieren
    cpu = task_states[current_task];
   
    return cpu;
}
timer_irq_handler.c

Code: [Auswählen]

#include <stdint.h>

#include "cpu.h"
#include "gdt.h"
#include "multitasking.h"

static uint32_t tss[TSS_SIZE];

cpu_state* timer_irq_handler(cpu_state *cpu){
    cpu_state *new_cpu = schedule(cpu);
    tss[1] = (uint32_t) (new_cpu + 1);
   
    send_eoi(0);
    return new_cpu;
}
irq handler:

Code: [Auswählen]

// Gemeinsamer interrupt handler
.extern common_intrpt_handler
.extern common_intrpt_handler_with_new_cpu
// IRQ - Handler
.extern timer_irq_handler
.extern keyboard_irq_handler

.macro irq_empty nr
.global int_handler\nr
int_handler\nr:
  iret
.endm

.macro irq nr isr
.global int_handler\nr
int_handler\nr:
  push $0
  push $\nr
  push $\isr
  jmp common_intrpt_handler
.endm

.macro irq_with_new_cpu nr isr
.global int_handler\nr
int_handler\nr:
  push $0
  push $\nr
  push $\isr
  jmp common_intrpt_handler_with_new_cpu
.endm

irq_with_new_cpu 0x20 timer_irq_handler
irq 0x21 keyboard_irq_handler
irq_empty 0x22
irq_empty 0x23
irq_empty 0x24
irq_empty 0x25
irq_empty 0x26
irq_empty 0x27
irq_empty 0x28
irq_empty 0x29
irq_empty 0x2A
irq_empty 0x2B
irq_empty 0x2C
irq_empty 0x2D
irq_empty 0x2E
irq_empty 0x2F

//Ende - handler.S

common handler:

Code: [Auswählen]

.global common_intrpt_handler_with_new_cpu
common_intrpt_handler_with_new_cpu:
  // ISR nach eax legen
  pop %ebx
 
  push %ebp
  push %edi
  push %esi
  push %edx
  push %ecx
  push %ebx
  push %eax
 
  // Kernel-Datensegmente laden
  mov $0x10, %ax
  mov %ax, %ds
  mov %eax, %es
 
  // ISR aufrufen
  push %esp
  call *%ebx
  mov %eax, %esp //Neuen Stack laden
 
  // User-Datensegmente laden
  mov $0x23, %ax
  mov %ax, %ds
  mov %ax, %es
 
  // Neue cpu herstellen
  pop %eax
  pop %ebx
  pop %ecx
  pop %edx
  pop %esi
  pop %edi
  pop %ebp
 
  // Errorcode und Interruptnummer vom Stack nehmen
  add $8, %esp
  iret
gdt.c

Code: [Auswählen]

#include <stdint.h>
#include "gdt.h"

/* ---------- Globale Variablen ----------------------- */
static uint64_t gdt[GDT_ENTRIES]; //Global Deskriptor Table
static uint32_t tss[TSS_SIZE] = {0, 0, 0x10}; //Task State Segment
/* ---------- Eintrag in die GDT setzen --------------- */
void set_gdt_entry(int i, uint32_t limit, uint32_t base, uint8_t access, uint8_t flags){
  gdt[i] = 0;
  //untere 32-Bit
  gdt[i] = (limit & 0x0ffff) | ((base & 0x0000ffff) << 16);
  //obere 32-Bit
  gdt[i] |=(
    ( (base & 0x00ff0000) >> 16 ) |
    ( access << 8 ) |
    ( flags << 16 ) |
    ( (limit & 0xf0000) << 4) |
    ( (base & 0xff000000) << 56 )
   ) * 0x100000000;
}
/* ---------- GDT Laden (GDTR ändern) ----------------- */
void load_gdt(void){
  struct {
    uint16_t size;
    uint64_t *pointer;
  } __attribute__((packed)) gdtp = {
    .size = GDT_ENTRIES * 8 - 1,
    .pointer = gdt,
  };
  asm volatile("lgdt %0" : : "m" (gdtp));//GDT Laden
}
/* ---------- GDT initalisieren ----------------------- */
void init_gdt(void){
 
  //Nulldeskriptor
    set_gdt_entry(0, 0, 0, 0, 0);

  //Kernel - Codesegment
    set_gdt_entry(1, 0xfffff, 0, //index, limit, base
GDT_CODESEG_RD | GDT_SEGMENT | GDT_RING0 | GDT_PRESENT,//Access-Byte
GDT_32_BIT  | GDT_4K_GRAN); //Flags
     
  //Kernel - Datensegment      
    set_gdt_entry(2, 0xfffff, 0,     //index, limit, base
GDT_DATASEG_WR | GDT_SEGMENT | GDT_RING0 | GDT_PRESENT,//Access-Byte
GDT_32_BIT  | GDT_4K_GRAN);       //Flags
     
  //Userspace - Codesegment    
    set_gdt_entry(3, 0xfffff, 0, //index, limit, base
GDT_CODESEG_RD | GDT_SEGMENT | GDT_RING3 | GDT_PRESENT,//Access-Byte
GDT_32_BIT  | GDT_4K_GRAN); //Flags
     
  //Userpsace - Datensegment      
    set_gdt_entry(4, 0xfffff, 0, //index, limit, base
GDT_DATASEG_WR | GDT_SEGMENT | GDT_RING3 | GDT_PRESENT,//Access-Byte
         GDT_32_BIT  | GDT_4K_GRAN); //Flags
   
  //Task State Segment
    set_gdt_entry(5, sizeof(tss)-1, (uint32_t) &tss, //index, limit, base
GDT_TSS | GDT_PRESENT | GDT_RING3, //Access-Byte
GDT_32_BIT  | GDT_4K_GRAN); //Flags

   // nach ss0 das Kernel Datensegment legen
    tss[2] = 0x10;
}
/* ---------- GDT schnell initalisieren --------------- */
void init_gdt_fast(void){
  gdt[0] = 0x0000000000000000;//Nulldeskriptor
  gdt[1] = 0x00FC9A000000FFFF;//Kernel - Codesegment
  gdt[2] = 0x00FC92000000FFFF;//Kernel - Datensegment
  gdt[3] = 0x00FCFA000000FFFF;//Userspace - Codesegment
  gdt[4] = 0x00FCF2000000FFFF;//Userpsace - Datensegment
//   gdt[5] = 0x0000000000000000;//Task State Segment
}
/* ---------- Segmenregister neuladen ----------------- */
void reload_segment_registers(void){
  asm volatile(
"ljmpl $0x08, $1f\n\t"
"1:\n\t"
        "mov $0x10, %eax\n\t"
        "mov %eax, %ds\n\t"
        "mov %eax, %es\n\t"
        "mov %eax, %fs\n\t"
        "mov %eax, %gs\n\t"
        "mov %eax, %ss\n\t"
  );
}
/* ---------- Taskregister neuladen ------------------- */
void reload_task_registers(void){
  asm volatile("ltr %%ax" : : "a" (5 << 3));
}

75

Lowlevel-Coding / Re: Timernterrupt kommt bei Multitasking nicht

« am: 11. April 2012, 20:31 »

Entschuldige, dass ich jetzt diesen Thread erstellt habe, aber immer wenn ich was im Forum frage und niemand antwortet, finde ich den Fehler schnell ( vielleicht sollte ich das öfters machen  ):
Ich habe den eoi erst nach dem herstallen der cpu gesendet! Der sollte eher kommen! Es geht!

76

Das Wiki / Re: outb in Tutorials

« am: 11. April 2012, 19:39 »

Debugblub

Ist das der -g parameter? wenn ja, dann mach ich das.

77

Lyrisches Eck / Re: Wortspiel

« am: 11. April 2012, 17:14 »

Vielleicht können wir jetzt auch mit vier wörtern weitermachen

Beispiel:
Die Variablen variieren wahrlos weiter

78

Lowlevel-Coding / Timernterrupt kommt bei Multitasking nicht

« am: 11. April 2012, 17:01 »

Ich hab gehofft, das bekomme ich wenigstens selber hin....

Ja, sobald mein Kernel im ersten Task (task_a) ist, wird kein IRQ, also kein Timerinterrupt mehr ausgelöst.

Code: [Auswählen]

#include <stdint.h>
#include "interrupt.h"
#include "cpu.h"
#include "console.h"


/* ---------- Globale Variablen ----------------------- */
static uint8_t stack_a[4096];
static uint8_t stack_b[4096];

static int current_task = -1;
static int num_tasks = 2;
static cpu_state* task_states[2];
/* --------- Tasks ------------- */
void task_a(void){
  while(1){
    setColor(0x02);
    printf("A");
  }
}
void task_b(void){
  while(1){
    setColor(0x06);
    printf("B");
  }
}
/* ---------- Task initalisieren ---------------------- */
cpu_state* init_task(uint8_t *stack, void *entry){
    cpu_state new_state = {
.eax = 0,
.ebx = 0,
.ecx = 0,
.edx = 0,
.esi = 0,
.edi = 0,
.ebp = 0,
        //.esp = Unbenutzt
.eip = (uint32_t) entry,

// Ring-0 Segmentregister
.cs = 0x08,
//.ss = unbenutzt

//IRQs einschalten
.eflags = 0x202,
    };
   
    cpu_state *state = (void*) (stack + 4096 - 56/*sizeof(new_state)*/);
    *state = new_state;
   
    return state;
}
/* ---------- Multitasking initalisieren -------------- */
void init_multitasking(void){
    task_states[0] = init_task(stack_a, task_a);
    task_states[1] = init_task(stack_b, task_b);
}
/* ---------- Scheduler ------------------------------- */
cpu_state* schedule(cpu_state *cpu){
   
    // Alten zustand des Tasks sichern
    if(current_task >= 0){
task_states[current_task] = cpu;
    }
   
    // Nächsten Task auswählen
    current_task++;
    current_task %= num_tasks;
   
    // Neuen Task aktivieren
    cpu = task_states[current_task];
   
    return cpu;
}

/* --------- ENDE -- multitasking.c ---*/
Also hab ich ersmal folgendes gemacht:

Code: [Auswählen]

/* --------- Tasks ------------- */
void task_a(void){
  while(1){
    setColor(0x02);
    printf("A");
    asm("int $0x20");
  }
}
void task_b(void){
  while(1){
    setColor(0x06);
    printf("B");
    asm("int $0x20");
  }
}Da funktionierts! aber das ist ja keine Lösung.

init_multitasking rufe ich auch vor cli auf.

79

Softwareentwicklung / Re: Qemu und Oracle...

« am: 11. April 2012, 16:53 »

Ja, dort liegen logs.
Dch dort wird bestimmt nicht drinstehen, warum VBox nicht startet.

80

Das Wiki / Re: outb in Tutorials

« am: 11. April 2012, 16:51 »

Man könnte behaupten, aufgrund des static inline wird der Compiler die Funktion praktisch überall direkt in den Code einfügen, so, als ob es eigentlich ein Macro wäre – praktisch würde gcc das wohl auch ohne das inline tun, weil sie so kurz ist.

tl;dr: So ein Macro brächte keinen echten Vorteil, daher wird eine Funktion definiert.

Bin ich nicht der Meinung! Wenn ich mein kernel mit den Funktionen dissasembliere, fügt gcc mir das nicht ein!